Merge branch 'master' into mymaster

2024-09-20 06:45:49 -04:00 · 2023-06-29 10:20:38 +01:00 · 2023-06-29 10:20:38 +01:00 · 57e9e8d92f
commit 57e9e8d92f
parent d82b733182 fab6a21a77
39 changed files with 1730 additions and 249 deletions
--- a/01.md
+++ b/01.md
@ -4,7 +4,7 @@ NIP-01
 Basic protocol flow description
 -------------------------------
-`draft` `mandatory` `author:fiatjaf` `author:distbit` `author:scsibug` `author:kukks` `author:jb55`
+`draft` `mandatory` `author:fiatjaf` `author:distbit` `author:scsibug` `author:kukks` `author:jb55` `author:semisol`
 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.
@ -16,7 +16,7 @@ The only object type that exists is the `event`, which has the following format
 ```json
 {
-  "id": <32-bytes lowercase hex-encoded sha256 of the the serialized event data>
+  "id": <32-bytes lowercase hex-encoded sha256 of the serialized event data>,
  "pubkey": <32-bytes lowercase hex-encoded public key of the event creator>,
  "created_at": <unix timestamp in seconds>,
  "kind": <integer>,
@ -86,9 +86,10 @@ The `limit` property of a filter is only valid for the initial query and can be
 ### From relay to client: sending events and notices
-Relays can send 2 types of messages, which must also be JSON arrays, according to the following patterns:
+Relays can send 3 types of messages, which must also be JSON arrays, according to the following patterns:
  * `["EVENT", <subscription_id>, <event JSON as defined above>]`, used to send events requested by clients.
  * `["EOSE", <subscription_id>]`, used to indicate the _end of stored events_ and the beginning of events newly received in real-time.
  * `["NOTICE", <message>]`, used to send human-readable error messages or other things to clients.
 This NIP defines no rules for how `NOTICE` messages should be sent or treated.
@ -98,7 +99,7 @@ This NIP defines no rules for how `NOTICE` messages should be sent or treated.
 ## Basic Event Kinds
  - `0`: `set_metadata`: the `content` is set to a stringified JSON object `{name: <username>, about: <string>, picture: <url, string>}` describing the user who created the event. A relay may delete past `set_metadata` events once it gets a new one for the same pubkey.
-  - `1`: `text_note`: the `content` is set to the plaintext content of a note (anything the user wants to say). Markdown links (`[]()` stuff) are not plaintext.
+  - `1`: `text_note`: the `content` is set to the **plaintext** content of a note (anything the user wants to say). Content that must be parsed, such as Markdown and HTML, should not be used. Clients should also not parse content as those.
  - `2`: `recommend_server`: the `content` is set to the URL (e.g., `wss://somerelay.com`) of a relay the event creator wants to recommend to its followers.
 A relay may choose to treat different message kinds differently, and it may or may not choose to have a default way to handle kinds it doesn't know about.
@ -106,5 +107,7 @@ A relay may choose to treat different message kinds differently, and it may or m
 ## Other Notes:
 - Clients should not open more than one websocket to each relay. One channel can support an unlimited number of subscriptions, so clients should do that.
- The `tags` array can store a tag identifier as the first element of each subarray, plus arbitrary information afterward (always as strings). This NIP defines `"p"` — meaning "pubkey", which points to a pubkey of someone that is referred to in the event —, and `"e"` — meaning "event", which points to the id of an event this event is quoting, replying to or referring to somehow.
+- The `tags` array can store a tag identifier as the first element of each subarray, plus arbitrary information afterward (always as strings). This NIP defines `"p"` — meaning "pubkey", which points to a pubkey of someone that is referred to in the event —, and `"e"` — meaning "event", which points to the id of an event this event is quoting, replying to or referring to somehow. See [NIP-10](10.md) for a detailed description of "e" and "p" tags.
 - The `<recommended relay URL>` item present on the `"e"` and `"p"` tags is an optional (could be set to `""`) URL of a relay the client could attempt to connect to fetch the tagged event or other events from a tagged profile. It MAY be ignored, but it exists to increase censorship resistance and make the spread of relay addresses more seamless across clients.
 - Clients should use the created_at field to judge the age of a metadata event and completely replace older metadata events with newer metadata events regardless of the order in which they arrive.  Clients should not merge any filled fields within older metadata events into empty fields of newer metadata events.
 - When a websocket is closed by the relay with a status code 4000 that means the client shouldn't try to connect again.
--- a/02.md
+++ b/02.md
@ -22,6 +22,7 @@ For example:
  ],
  "content": "",
  ...other fields
 }
 ```
 Every new contact list that gets published overwrites the past ones, so it should contain all entries. Relays and clients SHOULD delete past contact lists as soon as they receive a new one.
--- a/04.md
+++ b/04.md
@ -20,15 +20,15 @@ Code sample for generating such an event in JavaScript:
 ```js
 import crypto from 'crypto'
-import * as secp from 'noble-secp256k1'
+import * as secp from '@noble/secp256k1'
 let sharedPoint = secp.getSharedSecret(ourPrivateKey, '02' + theirPublicKey)
-let sharedX = sharedPoint.slice(2, 67)
+let sharedX = sharedPoint.slice(1, 33)
 let iv = crypto.randomFillSync(new Uint8Array(16))
 var cipher = crypto.createCipheriv(
  'aes-256-cbc',
-  Buffer.from(sharedX, 'hex'),
+  Buffer.from(sharedX),
  iv
 )
 let encryptedMessage = cipher.update(text, 'utf8', 'base64')
@ -43,3 +43,11 @@ let event = {
  content: encryptedMessage + '?iv=' + ivBase64
 }
 ```
 ## Security Warning
 This standard does not go anywhere near what is considered the state-of-the-art in encrypted communication between peers, and it leaks metadata in the events, therefore it must not be used for anything you really need to keep secret, and only with relays that use `AUTH` to restrict who can fetch your `kind:4` events.
 ## Client Implementation Warning
 Clients *should not* search and replace public key or note references from the `.content`. If processed like a regular text note (where `@npub...` is replaced with `#[0]` with a `["p", "..."]` tag) the tags are leaked and the mentioned user will receive the message in their inbox.
--- a/05.md
+++ b/05.md
@ -6,7 +6,7 @@ Mapping Nostr keys to DNS-based internet identifiers
 `final` `optional` `author:fiatjaf` `author:mikedilger`
-On events of kind `0` (`set_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` (`set_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.
 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>`.
@ -50,7 +50,7 @@ or with the **optional** `"relays"` attribute:
 If the pubkey matches the one given in `"names"` (as in the example above) that means the association is right and the `"nip05"` identifier is valid and can be displayed.
-The optional `"relays"` attribute may contain an object with public keys as properties and arrays of relay URLs as values. When present, that can be used to help clients learn in which relays that user may be found. Web servers which serve `/.well-known/nostr.json` files dynamically based on the query string SHOULD also serve the relays data for any name they serve in the same reply when that is available.
+The optional `"relays"` attribute may contain an object with public keys as properties and arrays of relay URLs as values. When present, that can be used to help clients learn in which relays the specific user may be found. Web servers which serve `/.well-known/nostr.json` files dynamically based on the query string SHOULD also serve the relays data for any name they serve in the same reply when that is available.
 ## Finding users from their NIP-05 identifier
@ -64,7 +64,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 are only meant to be used for display in client UIs, not in this NIP.
+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.
 ### User Discovery implementation suggestion
@ -76,7 +76,7 @@ Clients may treat the identifier `_@domain` as the "root" identifier, and choose
 ### Reasoning for the `/.well-known/nostr.json?name=<local-part>` format
-By adding the `<local-part>` as a query string instead of as part of the path the protocol can support both dynamic servers that can generate JSON on-demand and static servers with a JSON file in it that may contain multiple names.
+By adding the `<local-part>` as a query string instead of as part of the path, the protocol can support both dynamic servers that can generate JSON on-demand and static servers with a JSON file in it that may contain multiple names.
 ### Allowing access from JavaScript apps
--- a/06.md
+++ b/06.md
@ -8,8 +8,8 @@ Basic key derivation from mnemonic seed phrase
 [BIP39](https://bips.xyz/39) is used to generate mnemonic seed words and derive a binary seed from them.
-[BIP32](https://bips.xyz/32) is used to derive the path `m/44'/1237'/0'/0/0` (according to the Nostr entry on [SLIP44](https://github.com/satoshilabs/slips/blob/master/slip-0044.md)).
+[BIP32](https://bips.xyz/32) is used to derive the path `m/44'/1237'/<account>'/0/0` (according to the Nostr entry on [SLIP44](https://github.com/satoshilabs/slips/blob/master/slip-0044.md)).
-This is the default for a basic, normal, single-key client.
+A basic client can simply use an `account` of `0` to derive a single key. For more advanced use-cases you can increment `account`, allowing generation of practically infinite keys from the 5-level path with hardened derivation.
 Other types of clients can still get fancy and use other derivation paths for their own other purposes.
--- a/07.md
+++ b/07.md
@ -24,7 +24,12 @@ async window.nostr.nip04.decrypt(pubkey, ciphertext): string // takes ciphertext
 ### Implementation
 - [horse](https://github.com/fiatjaf/horse) (Chrome and derivatives)
 - [nos2x](https://github.com/fiatjaf/nos2x) (Chrome and derivatives)
- [Alby](https://getalby.com) (Chrome and derivatives, Firefox, Safari)
+- [Alby](https://getalby.com) (Chrome and derivatives, Firefox)
 - [Blockcore](https://www.blockcore.net/wallet) (Chrome and derivatives)
 - [nos2x-fox](https://diegogurpegui.com/nos2x-fox/) (Firefox)
 - [Flamingo](https://www.getflamingo.org/) (Chrome and derivatives)
 - [AKA Profiles](https://github.com/neilck/aka-extension) (Chrome, stores multiple keys)
 - [TokenPocket](https://www.tokenpocket.pro/) (Android, IOS, Chrome and derivatives)
 - [Nostrmo](https://github.com/haorendashu/nostrmo_faq#download) (Android, IOS)
--- a/08.md
+++ b/08.md
@ -1,10 +1,12 @@
 > __Warning__  `unrecommended`: deprecated in favor of [NIP-27](27.md)
 NIP-08
 ======
 Handling Mentions
 -----------------
-`final` `optional` `author:fiatjaf` `author:scsibug`
+`final` `unrecommended` `optional` `author:fiatjaf` `author:scsibug`
 This document standardizes the treatment given by clients of inline mentions of other events and pubkeys inside the content of `text_note`s.
--- a/09.md
+++ b/09.md
@ -8,7 +8,7 @@ Event Deletion
 A special event with kind `5`, meaning "deletion" is defined as having a list of one or more `e` tags, each referencing an event the author is requesting to be deleted.
-Each tag entry must contain an "e" event id intended for deletion.
+Each tag entry must contain an "e" event id and/or NIP-33 `a` tags intended for deletion.
 The event's `content` field MAY contain a text note describing the reason for the deletion.
@ -21,19 +21,20 @@ For example:
  "tags": [
    ["e", "dcd59..464a2"],
    ["e", "968c5..ad7a4"],
    ["a", "<kind>:<pubkey>:<d-identifier>"]
  ],
  "content": "these posts were published by accident",
  ...other fields
 }
 ```
-Relays SHOULD delete or stop publishing any referenced events that have an identical `id` as the deletion request.  Clients SHOULD hide or otherwise indicate a deletion status for referenced events.
+Relays SHOULD delete or stop publishing any referenced events that have an identical `pubkey` as the deletion request.  Clients SHOULD hide or otherwise indicate a deletion status for referenced events.
 Relays SHOULD continue to publish/share the deletion events indefinitely, as clients may already have the event that's intended to be deleted. Additionally, clients SHOULD broadcast deletion events to other relays which don't have it.
 ## Client Usage
-Clients MAY choose to fully hide any events that are referenced by valid deletion events.  This includes text notes, direct messages, or other yet-to-be defined event kinds.  Alternatively, they MAY show the event along with an icon or other indication that the author has "disowned" the event.  The `content` field MAY also be used to replace the deleted event's own content, although a user interface should clearly indicate that this is a deletion reason, not the original content.
+Clients MAY choose to fully hide any events that are referenced by valid deletion events.  This includes text notes, direct messages, or other yet-to-be defined event kinds.  Alternatively, they MAY show the event along with an icon or other indication that the author has "disowned" the event.  The `content` field MAY also be used to replace the deleted events' own content, although a user interface should clearly indicate that this is a deletion reason, not the original content.
 A client MUST validate that each event `pubkey` referenced in the `e` tag of the deletion request is identical to the deletion request `pubkey`, before hiding or deleting any event.  Relays can not, in general, perform this validation and should not be treated as authoritative.
--- a/11.md
+++ b/11.md
@ -4,7 +4,7 @@ NIP-11
 Relay Information Document
 ---------------------------
-`draft` `optional` `author:scsibug`
+`draft` `optional` `author:scsibug` `author:doc-hex` `author:cameri`
 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.
@ -56,3 +56,242 @@ The relay server implementation MAY be provided in the `software` attribute.  If
 ### 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.
 Extra Fields
 -----------------
 ### Server Limitations ###
 These are limitations imposed by the relay on clients. Your client
 should expect that requests which exceed these *practical* limitations
 are rejected or fail immediately.
 ```json
 {
 ...
  "limitation": {
        "max_message_length": 16384,
        "max_subscriptions": 20,
        "max_filters": 100,
        "max_limit": 5000,
        "max_subid_length": 100,
        "min_prefix": 4,
        "max_event_tags": 100,
        "max_content_length": 8196,
        "min_pow_difficulty": 30,
        "auth_required": true,
        "payment_required": true,
  }
 ...
 }
 ```
 - `max_message_length`: this is the maximum number of bytes for incoming JSON that the relay
 will attempt to decode and act upon. When you send large subscriptions, you will be
 limited by this value. It also effectively limits the maximum size of any event. Value is
 calculated from `[` to `]` and is after UTF-8 serialization (so some unicode characters
 will cost 2-3 bytes). It is equal to the maximum size of the WebSocket message frame.
 - `max_subscriptions`: total number of subscriptions that may be
 active on a single websocket connection to this relay. It's possible
 that authenticated clients with a (paid) relationship to the relay
 may have higher limits.
 - `max_filters`: maximum number of filter values in each subscription.
 Must be one or higher.
 - `max_subid_length`: maximum length of subscription id as a string.
 - `min_prefix`: for `authors` and `ids` filters which are to match against
 a hex prefix, you must provide at least this many hex digits in the prefix.
 - `max_limit`: the relay server will clamp each filter's `limit` value to this number.
 This means the client won't be able to get more than this number
 of events from a single subscription filter. This clamping is typically done silently
 by the relay, but with this number, you can know that there are additional results
 if you narrowed your filter's time range or other parameters.
 - `max_event_tags`: in any event, this is the maximum number of elements in the `tags` list.
 - `max_content_length`: maximum number of characters in the `content`
 field of any event. This is a count of unicode characters. After
 serializing into JSON it may be larger (in bytes), and is still
 subject to the `max_message_length`, if defined.
 - `min_pow_difficulty`: new events will require at least this difficulty of PoW, 
 based on [NIP-13](13.md), or they will be rejected by this server.
 - `auth_required`: this relay requires [NIP-42](42.md) authentication
 to happen before a new connection may perform any other action.
 Even if set to False, authentication may be required for specific actions.
 - `payment_required`: this relay requires payment before a new connection may perform any action.
 ### 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.
 ```json
 {
 ...
  "retention": [
    { "kinds": [0, 1, [5, 7], [40, 49]], "time": 3600 },
    { "kinds": [[40000, 49999]], "time": 100 },
    { "kinds": [[30000, 39999]], "count": 1000 },
    { "time": 3600, "count": 10000 }
  ]
 ...
 }
 ```
 `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_ as defined
 in [NIP-16](16.md) 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 cleartext 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 favourable zones. Exposing this
 flexibility is up to the client software.
 ```json
 {
 ...
  "relay_countries": [ "CA", "US" ],
 ...
 }
 ```
 - `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.
 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.
 ```json
 {
 ...
  "language_tags": [ "en", "en-419" ],
  "tags": [ "sfw-only", "bitcoin-only", "anime" ],
  "posting_policy": "https://example.com/posting-policy.html",
 ...
 }
 ```
 - `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.
 - `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 ###
 Relays that require payments may want to expose their fee schedules.
 ```json
 {
 ...
  "payments_url": "https://my-relay/payments",
  "fees": {
    "admission": [{ "amount": 1000000, "unit": "msats" }],
    "subscription": [{ "amount": 5000000, "unit": "msats", "period": 2592000 }],
    "publication": [{ "kinds": [4], "amount": 100, "unit": "msats" }],
  },
 ...
 }
 ```
 ### Icon ###
 A URL pointing to an image to be used as an icon for the relay. Recommended to be squared in shape.
 ```json
 {
 ...
  "icon": "https://nostr.build/i/53866b44135a27d624e99c6165cabd76ac8f72797209700acb189fce75021f47.jpg",
 ...
 }
 ```
 ### Examples ###
 As of 2 May 2023 the following `curl` command provided these results.
 	>curl -H "Accept: application/nostr+json" https://eden.nostr.land
 	{"name":"eden.nostr.land",
 	"description":"Eden Nostr Land - Toronto 1-01",
 	"pubkey":"00000000827ffaa94bfea288c3dfce4422c794fbb96625b6b31e9049f729d700",
 	"contact":"me@ricardocabral.io",
 	"supported_nips":[1,2,4,9,11,12,15,16,20,22,26,28,33,40],
 	"supported_nip_extensions":["11a"],
 	"software":"git+https://github.com/Cameri/nostream.git",
 	"version":"1.22.6",
 	"limitation":{"max_message_length":1048576,
 				  "max_subscriptions":10,
 				  "max_filters":2500,
 				  "max_limit":5000,
 				  "max_subid_length":256,
 				  "min_prefix":4,
 				  "max_event_tags":2500,
 				  "max_content_length":65536,
 				  "min_pow_difficulty":0,
 				  "auth_required":false,
 				  "payment_required":true},
 	"payments_url":"https://eden.nostr.land/invoices",
 	"fees":{"admission":[{"amount":5000000,"unit":"msats"}],
 	        "publication":[]}}, 
    "icon": "https://nostr.build/i/53866b44135a27d624e99c6165cabd76ac8f72797209700acb189fce75021f47.jpg"
--- a/13.md
+++ b/13.md
@ -10,13 +10,15 @@ This NIP defines a way to generate and interpret Proof of Work for nostr notes.
 `difficulty` is defined to be the number of leading zero bits in the `NIP-01` id. For example, an id of `000000000e9d97a1ab09fc381030b346cdd7a142ad57e6df0b46dc9bef6c7e2d` has a difficulty of `36` with `36` leading 0 bits.
 `002f...` is `0000 0000 0010 1111...` in binary, which has 10 leading zeroes. Do not forget to count leading zeroes for hex digits <= `7`.
 Mining
 ------
 To generate PoW for a `NIP-01` note, a `nonce` tag is used:
 ```json
-{"content": "It's just me mining my own business", "tags": [["nonce", "1", "20"]]}
+{"content": "It's just me mining my own business", "tags": [["nonce", "1", "21"]]}
 ```
 When mining, the second entry to the nonce tag is updated, and then the id is recalculated (see [NIP-01](./01.md)). If the id has the desired number of leading zero bits, the note has been mined. It is recommended to update the `created_at` as well during this process.
@ -36,7 +38,7 @@ Example mined note
    [
      "nonce",
      "776797",
-      "20"
+      "21"
    ]
  ],
  "content": "It's just me mining my own business",
@ -47,33 +49,61 @@ Example mined note
 Validating
 ----------
-Here is some reference C code for calculating the difficulty (aka number of leading zero bits) in a nostr note id:
+Here is some reference C code for calculating the difficulty (aka number of leading zero bits) in a nostr event id:
 ```c
-int zero_bits(unsigned char b)
+#include <stdio.h>
-{
+#include <stdlib.h>
-        int n = 0;
+#include <string.h>
-        if (b == 0)
+int countLeadingZeroes(const char *hex) {
-                return 8;
+    int count = 0;
-        while (b >>= 1)
+    for (int i = 0; i < strlen(hex); i++) {
-                n++;
+        int nibble = (int)strtol((char[]){hex[i], '\0'}, NULL, 16);
-
+        if (nibble == 0) {
-        return 7-n;
+            count += 4;
-}
+        } else {
-
+            count += __builtin_clz(nibble) - 28;
 /* find the number of leading zero bits in a hash */
 int count_leading_zero_bits(unsigned char *hash)
 {
        int bits, total, i;
        for (i = 0, total = 0; i < 32; i++) {
                bits = zero_bits(hash[i]);
                total += bits;
                if (bits != 8)
            break;
        }
-        return total;
+    }
    return count;
 }
 int main(int argc, char *argv[]) {
    if (argc != 2) {
        fprintf(stderr, "Usage: %s <hex_string>\n", argv[0]);
        return 1;
    }
    const char *hex_string = argv[1];
    int result = countLeadingZeroes(hex_string);
    printf("Leading zeroes in hex string %s: %d\n", hex_string, result);
    return 0;
 }
 ```
 Here is some JavaScript code for doing the same thing:
 ```javascript
 // hex should be a hexadecimal string (with no 0x prefix)
 function countLeadingZeroes(hex) {
  let count = 0;
  for (let i = 0; i < hex.length; i++) {
    const nibble = parseInt(hex[i], 16);
    if (nibble === 0) {
      count += 4;
    } else {
      count += Math.clz32(nibble) - 28;
      break;
    }
  }
  return count;
 }
 ```
@ -90,4 +120,4 @@ $ echo '["REQ", "subid", {"ids": ["000000000"]}]'  | websocat wss://some-relay.c
 Delegated Proof of Work
 -----------------------
-Since the `NIP-01` note id does not commit to any signature, PoW can be outsourced to PoW providers, perhaps for a fee. This provides a way for clients to get their messages out to PoW-restricted relays without having to do any work themselves, which is useful for energy constrained devices like on mobile
+Since the `NIP-01` note id does not commit to any signature, PoW can be outsourced to PoW providers, perhaps for a fee. This provides a way for clients to get their messages out to PoW-restricted relays without having to do any work themselves, which is useful for energy-constrained devices like mobile phones.
--- a/15.md
+++ b/15.md
@ -1,21 +1,214 @@
 NIP-15
 ======
-End of Stored Events Notice
+Nostr Marketplace (for resilient marketplaces)
---------------------------
+-----------------------------------
-`final` `optional` `author:Semisol`
+`draft` `optional` `author:fiatjaf` `author:benarc`  `author:motorina0` `author:talvasconcelos` 
-Relays may support notifying clients when all stored events have been sent.
+> Based on https://github.com/lnbits/Diagon-Alley
-If a relay supports this NIP, the relay SHOULD send the client a `EOSE` message in the format `["EOSE", <subscription_id>]` after it has sent all the events it has persisted and it indicates all the events that come after this message are newly published.
+> Implemented here https://github.com/lnbits/nostrmarket
-Client Behavior
+## Terms
 ---------------
-Clients SHOULD use the `supported_nips` field to learn if a relay supports end of stored events notices.
+- `merchant` - seller of products with NOSTR key-pair
 - `customer` - buyer of products with NOSTR key-pair
 - `product` - item for sale by the `merchant`
 - `stall` - list of products controlled by `merchant` (a `merchant` can have multiple stalls)
 - `marketplace` - clientside software for searching `stalls` and purchasing `products`
-Motivation
+## Nostr Marketplace Clients
 ----------
-The motivation for this proposal is to reduce uncertainty when all events have been sent by a relay to make client code possibly less complex.
+### Merchant admin
 Where the `merchant` creates, updates and deletes `stalls` and `products`, as well as where they manage sales, payments and communication with `customers`.
 The `merchant` admin software can be purely clientside, but for `convenience` and uptime, implementations will likely have a server client listening for NOSTR events.
 ### Marketplace
 `Marketplace` software should be entirely clientside, either as a stand-alone app, or as a purely frontend webpage. A `customer` subscribes to different merchant NOSTR public keys, and those `merchants` `stalls` and `products` become listed and searchable. The marketplace client is like any other ecommerce site, with basket and checkout. `Marketplaces` may also wish to include a `customer` support area for direct message communication with `merchants`.
 ## `Merchant` publishing/updating products (event)
 A merchant can publish these events:
 | Kind    |                  | Description                                                                                                   | NIP                                     |
 |---------|------------------|---------------------------------------------------------------------------------------------------------------|-----------------------------------------|
 | `0    ` | `set_meta`       | The merchant description (similar with any `nostr` public key).                                               | [NIP01       ](https://github.com/nostr-protocol/nips/blob/master/01.md)                            |
 | `30017` | `set_stall`      | Create or update a stall.                                                                                     | [NIP33](https://github.com/nostr-protocol/nips/blob/master/33.md) (Parameterized Replaceable Event) |
 | `30018` | `set_product`    | Create or update a product.                                                                                   | [NIP33](https://github.com/nostr-protocol/nips/blob/master/33.md) (Parameterized Replaceable Event) |
 | `4    ` | `direct_message` | Communicate with the customer. The messages can be plain-text or JSON. | [NIP04](https://github.com/nostr-protocol/nips/blob/master/04.md)                                            |
 | `5    ` | `delete`         | Delete a product or a stall.                                                                                  | [NIP09](https://github.com/nostr-protocol/nips/blob/master/09.md)                                   |
 ### Event `30017`: Create or update a stall.
 **Event Content**:
 ```json
 {
    "id": <String, UUID generated by the merchant. Sequential IDs (`0`, `1`, `2`...) are discouraged>,
    "name": <String, stall name>,
    "description": <String (optional), stall description>,
    "currency": <String, currency used>,
    "shipping": [
        {
            "id": <String, UUID of the shipping zone, generated by the merchant>,
            "name": <String (optional), zone name>,
            "cost": <float, cost for shipping. The currency is defined at the stall level>,
            "countries": [<String, countries included in this zone>],
        }
    ]
 }
 ```
 Fields that are not self-explanatory:
 - `shipping`:
   - an array with possible shipping zones for this stall. The customer MUST choose exactly one shipping zone.
   - shipping to different zones can have different costs. For some goods (digital for example) the cost can be zero.
   - the `id` is an internal value used by the merchant. This value must be sent back as the customer selection.
 **Event Tags**:
 ```json
  "tags": [["d", <String, id of stall]]
 ```
 - the `d` tag is required by [NIP33](https://github.com/nostr-protocol/nips/blob/master/33.md). Its value MUST be the same as the stall `id`.
 ### Event `30018`: Create or update a product
 **Event Content**:
 ```json
 {
    "id": <String, UUID generated by the merchant.Sequential IDs (`0`, `1`, `2`...) are discouraged>,
    "stall_id": <String, UUID of the stall to which this product belong to>,
    "name": <String, product name>,
    "description": <String (optional), product description>,
    "images": <[String], array of image URLs, optional>,
    "currency": <String, currency used>,
    "price": <float, cost of product>,
    "quantity": <int, available items>,
    "specs": [
      [ <String, spec key>, <String, spec value>]
     ]
 }
 ```
 Fields that are not self-explanatory:
 - `specs`:
   - an array of key pair values. It allows for the Customer UI to present present product specifications in a structure mode. It also allows comparison between products
   - eg: `[["operating_system", "Android 12.0"], ["screen_size", "6.4 inches"], ["connector_type", "USB Type C"]]`
 _Open_: better to move `spec` in the `tags` section of the event?
 **Event Tags**:
 ```json
  "tags": [
       ["d", <String, id of product],
       ["t", <String (optional), product category],
       ["t", <String (optional), product category],
       ...
    ]
 ```
 - the `d` tag is required by [NIP33](https://github.com/nostr-protocol/nips/blob/master/33.md). Its value MUST be the same as the product `id`.
 - the `t` tag is as searchable tag ([NIP12](https://github.com/nostr-protocol/nips/blob/master/12.md)). It represents different categories that the product can be part of (`food`, `fruits`). Multiple `t` tags can be present.
 ## Checkout events
 All checkout events are sent as JSON strings using ([NIP04](https://github.com/nostr-protocol/nips/blob/master/04.md)).
 The `merchant` and the `customer` can exchange JSON messages that represent different actions. Each `JSON` message `MUST` have a `type` field indicating the what the JSON represents. Possible types:
 | Message Type | Sent By  | Description         |
 |--------------|----------|---------------------|
 | 0            | Customer | New Order           |
 | 1            | Merchant | Payment Request     |
 | 2            | Merchant | Order Status Update |
 ### Step 1: `customer` order (event)
 The below json goes in content of [NIP04](https://github.com/nostr-protocol/nips/blob/master/04.md).
 ```json
 {
    "id": <String, UUID generated by the customer>,
    "type": 0,
    "name": <String (optional), ???>,
    "address": <String (optional), for physical goods an address should be provided>
    "message": "<String (optional), message for merchant>,
    "contact": {
        "nostr": <32-bytes hex of a pubkey>,
        "phone": <String (optional), if the customer wants to be contacted by phone>,
        "email": <String (optional), if the customer wants to be contacted by email>,
    },
    "items": [
        {
            "product_id": <String, UUID of the product>,
            "quantity": <int, how many products the customer is ordering>
        }
    ],
    "shipping_id": <String, UUID of the shipping zone>
 }
 ```
 _Open_: is `contact.nostr` required?
 ### Step 2: `merchant` request payment (event)
 Sent back from the merchant for payment. Any payment option is valid that the merchant can check.
 The below json goes in `content` of [NIP04](https://github.com/nostr-protocol/nips/blob/master/04.md).
 `payment_options`/`type` include:
 - `url` URL to a payment page, stripe, paypal, btcpayserver, etc
 - `btc` onchain bitcoin address
 - `ln` bitcoin lightning invoice
 - `lnurl` bitcoin lnurl-pay
 ```json
 {
    "id": <String, UUID of the order>,
    "type": 1,
    "message": <String, message to customer, optional>,
    "payment_options": [
        {
            "type": <String, option type>,
            "link": <String, url, btc address, ln invoice, etc>
        },
        {
            "type": <String, option type>,
            "link": <String, url, btc address, ln invoice, etc>
        },
                {
            "type": <String, option type>,
            "link": <String, url, btc address, ln invoice, etc>
        }
    ]
 }
 ```
 ### Step 3: `merchant` verify payment/shipped (event)
 Once payment has been received and processed.
 The below json goes in `content` of [NIP04](https://github.com/nostr-protocol/nips/blob/master/04.md).
 ```json
 {
    "id": <String, UUID of the order>,
    "type": 2,
    "message": <String, message to customer>,
    "paid": <Bool, true/false has received payment>,
    "shipped": <Bool, true/false has been shipped>,
 }
 ```
 ## Customer support events
 Customer support is handled over whatever communication method was specified. If communicating via nostr, NIP-04 is used https://github.com/nostr-protocol/nips/blob/master/04.md.
 ## Additional
 Standard data models can be found here <a href="https://raw.githubusercontent.com/lnbits/nostrmarket/main/models.py">here</a>
--- a/16.md
+++ b/16.md
@ -16,7 +16,11 @@ Upon a regular event being received, the relay SHOULD send it to all clients wit
 Replaceable Events
 ------------------
 A *replaceable event* is defined as an event with a kind `10000 <= n < 20000`.
-Upon a replaceable event with a newer timestamp than the currently known latest replaceable event with the same kind being received, and signed by the same key, the old event SHOULD be discarded and replaced with the newer event.
+Upon a replaceable event with a newer timestamp than the currently known latest replaceable event with the same kind and author being received, the old event SHOULD be discarded,
 effectively replacing what gets returned when querying for
 `author:kind` tuples.
 If two events have the same timestamp, the event with the lowest id (first in lexical order) SHOULD be retained, and the other discarded.
 Ephemeral Events
 ----------------
--- a/18.md
+++ b/18.md
@ -0,0 +1,34 @@
 NIP-18
 ======
 Reposts
 -------
 `draft` `optional` `author:jb55` `author:fiatjaf` `author:arthurfranca`
 A repost is a `kind 6` event that is used to signal to followers
 that a `kind 1` text note is worth reading.
 The `content` of a repost event is _the stringified JSON of the reposted note_. It MAY also be empty, but that is not recommended.
 The repost event MUST include an `e` tag with the `id` of the note that is
 being reposted. That tag MUST include a relay URL as its third entry
 to indicate where it can be fetched.
 The repost SHOULD include a `p` tag with the `pubkey` of the event being
 reposted.
 ## Quote Reposts
 Quote reposts are `kind 1` events with an embedded `e` tag
 (see [NIP-08](08.md) and [NIP-27](27.md)). Because a quote repost includes
 an `e` tag, it may show up along replies to the reposted note.
 ## Generic Reposts
 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
 of the reposted event as its value.
--- a/19.md
+++ b/19.md
@ -46,13 +46,14 @@ These possible standardized `TLV` types are indicated here:
    - for `nrelay`, this is the relay URL
    - for `naddr`, it is the identifier (the `"d"` tag) of the event being referenced
 - `1`: `relay`
-  - for `nprofile`, `nevent` and `naddr`, a relay in which the entity (profile or event) is more likely to be found, encoded as ascii
+  - for `nprofile`, `nevent` and `naddr`, _optionally_, a relay in which the entity (profile or event) is more likely to be found, encoded as ascii
  - this may be included multiple times
 - `2`: `author`
  - for `naddr`, the 32 bytes of the pubkey of the event
  - for `nevent`, _optionally_, the 32 bytes of the pubkey of the event
 - `3`: `kind`
  - for `naddr`, the 32-bit unsigned integer of the kind, big-endian
-
+  - for `nevent`, _optionally_, the 32-bit unsigned integer of the kind, big-endian
 ## Examples
@ -66,3 +67,4 @@ These possible standardized `TLV` types are indicated here:
 ## Notes
 - `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.
--- a/21.md
+++ b/21.md
@ -1,16 +1,16 @@
 NIP-21
 ======
-`nostr:` URL scheme
+`nostr:` URI scheme
 -------------------
 `draft` `optional` `author:fiatjaf`
-This NIP standardizes the usage of a common URL scheme for maximum interoperability and openness in the network.
+This NIP standardizes the usage of a common URI scheme for maximum interoperability and openness in the network.
 The scheme is `nostr:`.
-The identifiers that come after are expected to be the same as those defined in NIP-19 (except `nsec`).
+The identifiers that come after are expected to be the same as those defined in [NIP-19](https://github.com/nostr-protocol/nips/blob/master/19.md) (except `nsec`).
 ## Examples
--- a/22.md
+++ b/22.md
@ -22,7 +22,7 @@ This NIP formalizes restrictions on event timestamps as accepted by a relay and
 The event `created_at` field is just a unix timestamp and can be set to a time in the past or future. Relays accept and share events dated to 20 years ago or 50,000 years in the future. This NIP aims to define a way for relays that do not want to store events with *any* timestamp to set their own restrictions.
-[Replaceable events](16.md#replaceable-events) can behave rather unexpected if the user wrote them - or tried to write them - with a wrong system clock. Persisting an update with a backdated system now would result in the update not getting persisted without a notification and if they did the last update with a forward dated system, they will again fail to do another update with the now correct time.
+[Replaceable events](16.md#replaceable-events) can behave rather unexpectedly if the user wrote them - or tried to write them - with a wrong system clock. Persisting an update with a backdated system now would result in the update not getting persisted without a notification and if they did the last update with a forward dated system, they will again fail to do another update with the now correct time.
 A wide adoption of this NIP could create a better user experience as it would decrease the amount of events that appear wildly out of order or even from impossible dates in the distant past or future.
--- a/23.md
+++ b/23.md
@ -6,7 +6,7 @@ Long-form Content
 `draft` `optional` `author:fiatjaf`
-This NIP defines `kind:30023` (a parameterized replaceable event according to NIP-33) for long-form text content, generally referred to as "articles" or "blog posts".
+This NIP defines `kind:30023` (a parameterized replaceable event according to [NIP-33](33.md)) for long-form text content, generally referred to as "articles" or "blog posts". `kind:30024` has the same structure as `kind:30023` and is used to save long form drafts.
 "Social" clients that deal primarily with `kind:1` notes should not be expected to implement this NIP.
@ -31,17 +31,11 @@ These articles are meant to be editable, so they should make use of the replacea
 ### Linking
-The article may be linked to using the NIP-19 `naddr` code along with the `"a"` tag (see NIP-33 and NIP-19).
+The article may be linked to using the NIP-19 `naddr` code along with the `"a"` tag (see [NIP-33](33.md) and [NIP-19](19.md)).
 ### References
-Clients that support publishing NIP-23 events should implement support for parsing pasted NIP-19 `naddr` identifiers and adding them automatically to the list of `.tags` of the event, replacing the actual content with a string like `#[tag_index]` in the same way as NIP-08 -- or, if the reference is in the form of a URL (for example, `[click here](naddr1...)`) then they should be replaced with just the tag number directly as if link with that name existed at the bottom of the Markdown (for example, `[click here][0]`).
+References to other Nostr notes, articles or profiles must be made according to [NIP-27](27.md), i.e. by using [NIP-21](21.md) `nostr:...` links and optionally adding tags for these (see example below).
 Reader clients should parse the Markdown and replace these references with either internal links so the referenced events can be accessed directly, with NIP-21 `nostr:naddr1...` links or direct links to web clients that will handle these references.
 The idea here is that having these tags is that reader clients can display a list of backreferences at the bottom when one article mentions another.
 The same principles can be applied to `nevent1...`, `note1...`, `nprofile1...` or `npub1...`.
 ## Example Event
@ -49,7 +43,7 @@ The same principles can be applied to `nevent1...`, `note1...`, `nprofile1...` o
 {
  "kind": 30023,
  "created_at": 1675642635,
-  "content": "Lorem [ipsum][4] dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.\n\nRead more at #[3].",
+  "content": "Lorem [ipsum][nostr:nevent1qqst8cujky046negxgwwm5ynqwn53t8aqjr6afd8g59nfqwxpdhylpcpzamhxue69uhhyetvv9ujuetcv9khqmr99e3k7mg8arnc9] dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.\n\nRead more at nostr:naddr1qqzkjurnw4ksz9thwden5te0wfjkccte9ehx7um5wghx7un8qgs2d90kkcq3nk2jry62dyf50k0h36rhpdtd594my40w9pkal876jxgrqsqqqa28pccpzu.",
  "tags": [
    ["d", "lorem-ipsum"],
    ["title", "Lorem Ipsum"],
--- a/25.md
+++ b/25.md
@ -16,7 +16,7 @@ A reaction with `content` set to `-` SHOULD be interpreted as a "dislike" or
 "downvote". It SHOULD NOT be counted as a "like", and MAY be displayed as a
 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 tallys.
+separate tallies.
 The `content` MAY be an emoji, in this case it MAY be interpreted as a "like" or "dislike",
 or the client MAY display this emoji reaction on the post.
--- a/26.md
+++ b/26.md
@ -1,4 +1,4 @@
-NIP: 26
+NIP-26
 =======
 Delegated Event Signing
@ -52,7 +52,9 @@ For example, the following condition strings are valid:
 - `kind=0&kind=1&created_at>1675721813`
 - `kind=1&created_at>1674777689&created_at<1675721813`
-For the vast majority of use-cases, it is advisable that query strings should include a `created_at` ***after*** condition reflecting the current time, to prevent the delegatee from publishing historic notes on the delegator's behalf.
+For the vast majority of use-cases, it is advisable that:
 1. Query strings should include a `created_at` ***after*** condition reflecting the current time, to prevent the delegatee from publishing historic notes on the delegator's behalf.
 2. Query strings should include a `created_at` ***before*** condition that is not empty and is not some extremely distant time in the future. If delegations are not limited in time scope, they expose similar security risks to simply using the root key for authentication.
 #### Example
@ -101,6 +103,8 @@ The event should be considered a valid delegation if the conditions are satisfie
 Clients should display the delegated note as if it was published directly by the delegator (8e0d3d3e).
-#### Relay & Client Querying Support
+#### Relay & Client Support
 Relays should answer requests such as `["REQ", "", {"authors": ["A"]}]` by querying both the `pubkey` and delegation tags `[1]` value.
 Relays SHOULD allow the delegator (8e0d3d3e) to delete the events published by the delegatee (477318cf).
--- a/27.md
+++ b/27.md
@ -0,0 +1,54 @@
 NIP-27
 ======
 Text Note References
 --------------------
 `draft` `optional` `author:arthurfranca` `author:hodlbod` `author:fiatjaf`
 This document standardizes the treatment given by clients of inline references of other events and profiles inside the `.content` of any event that has readable text in its `.content` (such as kinds 1 and 30023).
 When creating an event, clients should include mentions to other profiles and to other events in the middle of the `.content` using [NIP-21](21.md) codes, such as `nostr:nprofile1qqsw3dy8cpu...6x2argwghx6egsqstvg`.
 Including [NIP-10](10.md)-style tags (`["e", <hex-id>, <relay-url>, <marker>]`) for each reference is optional, clients should do it whenever they want the profile being mentioned to be notified of the mention, or when they want the referenced event to recognize their mention as a reply.
 A reader client that receives an event with such `nostr:...` mentions in its `.content` can do any desired context augmentation (for example, linking to the profile or showing a preview of the mentioned event contents) it wants in the process. If turning such mentions into links, they could become internal links, [NIP-21](21.md) links or direct links to web clients that will handle these references.
 ---
 ## Example of a profile mention process
 Suppose Bob is writing a note in a client that has search-and-autocomplete functionality for users that is triggered when they write the character `@`.
 As Bob types `"hello @mat"` the client will prompt him to autocomplete with [mattn's profile](https://gateway.nostr.com/p/2c7cc62a697ea3a7826521f3fd34f0cb273693cbe5e9310f35449f43622a5cdc), showing a picture and name.
 Bob presses "enter" and now he sees his typed note as `"hello @mattn"`, `@mattn` is highlighted, indicating that it is a mention. Internally, however, the event looks like this:
 ```json
 {
  "content": "hello nostr:nprofile1qqszclxx9f5haga8sfjjrulaxncvkfekj097t6f3pu65f86rvg49ehqj6f9dh",
  "created_at": 1679790774,
  "id": "f39e9b451a73d62abc5016cffdd294b1a904e2f34536a208874fe5e22bbd47cf",
  "kind": 1,
  "pubkey": "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798",
  "sig": "f8c8bab1b90cc3d2ae1ad999e6af8af449ad8bb4edf64807386493163e29162b5852a796a8f474d6b1001cddbaac0de4392838574f5366f03cc94cf5dfb43f4d",
  "tags": [
    [
      "p",
      "2c7cc62a697ea3a7826521f3fd34f0cb273693cbe5e9310f35449f43622a5cdc"
    ]
  ]
 }
 ```
 (Alternatively, the mention could have been a `nostr:npub1...` URL.)
 After Bob publishes this event and Carol sees it, her client will initially display the `.content` as it is, but later it will parse the `.content` and see that there is a `nostr:` URL in there, decode it, extract the public key from it (and possibly relay hints), fetch that profile from its internal database or relays, then replace the full URL with the name `@mattn`, with a link to the internal page view for that profile.
 ## Verbose and probably unnecessary considerations
 - The example above was very concrete, but it doesn't mean all clients have to implement the same flow. There could be clients that do not support autocomplete at all, so they just allow users to paste raw [NIP-19](19.md) codes into the body of text, then prefix these with `nostr:` before publishing the event.
 - The flow for referencing other events is similar: a user could paste a `note1...` or `nevent1...` code and the client will turn that into a `nostr:note1...` or `nostr:nevent1...` URL. Then upon reading such references the client may show the referenced note in a preview box or something like that -- or nothing at all.
 - Other display procedures can be employed: for example, if a client that is designed for dealing with only `kind:1` text notes sees, for example, a [`kind:30023`](23.md) `nostr:naddr1...` URL reference in the `.content`, it can, for example, decide to turn that into a link to some hardcoded webapp capable of displaying such events.
 - Clients may give the user the option to include or not include tags for mentioned events or profiles. If someone wants to mention `mattn` without notifying them, but still have a nice augmentable/clickable link to their profile inside their note, they can instruct their client to _not_ create a `["p", ...]` tag for that specific mention.
 - In the same way, if someone wants to reference another note but their reference is not meant to show up along other replies to that same note, their client can choose to not include a corresponding `["e", ...]` tag for any given `nostr:nevent1...` URL inside `.content`. Clients may decide to expose these advanced functionalities to users or be more opinionated about things.
--- a/28.md
+++ b/28.md
@ -9,7 +9,7 @@ Public Chat
 This NIP defines new event kinds for public chat channels, channel messages, and basic client-side moderation.
-It reserves five event kinds (40-44) for immediate use and five event kinds (45-49) for future use.
+It reserves five event kinds (40-44) for immediate use:
 - `40 - channel create`
 - `41 - channel metadata`
@ -37,7 +37,7 @@ In the channel creation `content` field, Client SHOULD include basic channel met
 Update a channel's public metadata.
-Clients and relays SHOULD handle kind 41 events similar to kind 0 `metadata` events.
+Clients and relays SHOULD handle kind 41 events similar to kind 33 replaceable events, where the information is used to update the metadata, without modifying the event id for the channel.  Only the most recent kind 41 is needed to be stored.
 Clients SHOULD ignore kind 41s from pubkeys other than the kind 40 pubkey.
@ -84,6 +84,7 @@ Reply to another message:
 {
    "content": <string>,
    "tags": [
        ["e", <kind_40_event_id>, <relay-url>, "root"],
        ["e", <kind_42_event_id>, <relay-url>, "reply"],
        ["p", <pubkey>, <relay-url>],
        ...
@ -138,12 +139,6 @@ For [NIP-10](10.md) relay recommendations, clients generally SHOULD use the rela
 Clients MAY recommend any relay URL. For example, if a relay hosting the original kind 40 event for a channel goes offline, clients could instead fetch channel data from a backup relay, or a relay that clients trust more than the original relay.
 Future extensibility
 --------------------
 We reserve event kinds 45-49 for other events related to chat, to potentially include new types of media (photo/video), moderation, or support of private or group messaging.
 Motivation
 ----------
 If we're solving censorship-resistant communication for social media, we may as well solve it also for Telegram-style messaging.
--- a/30.md
+++ b/30.md
@ -0,0 +1,56 @@
 NIP-30
 ======
 Custom Emoji
 ------------
 `draft` `optional` `author:alexgleason`
 Custom emoji may be added to **kind 0** and **kind 1** events by including one or more `"emoji"` tags, in the form:
 ```
 ["emoji", <shortcode>, <image-url>]
 ```
 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.
 For each emoji tag, clients should parse emoji shortcodes (aka "emojify") like `:shortcode:` in the event to display custom emoji.
 Clients may allow users to add custom emoji to an event by including `:shortcode:` identifier in the event, and adding the relevant `"emoji"` tags.
 ### Kind 0 events
 In kind 0 events, the `name` and `about` fields should be emojified.
 ```json
 {
  "kind": 0,
  "content": "{\"name\":\"Alex Gleason :soapbox:\"}",
  "tags": [
    ["emoji", "soapbox", "https://gleasonator.com/emoji/Gleasonator/soapbox.png"]
  ],
  "pubkey": "79c2cae114ea28a981e7559b4fe7854a473521a8d22a66bbab9fa248eb820ff6",
  "created_at": 1682790000
 }
 ```
 ### Kind 1 events
 In kind 1 events, the `content` should be emojified.
 ```json
 {
  "kind": 1,
  "content": "Hello :gleasonator: 😂 :ablobcatrainbow: :disputed: yolo",
    "tags": [
    ["emoji", "ablobcatrainbow", "https://gleasonator.com/emoji/blobcat/ablobcatrainbow.png"],
    ["emoji", "disputed", "https://gleasonator.com/emoji/Fun/disputed.png"],
    ["emoji", "gleasonator", "https://gleasonator.com/emoji/Gleasonator/gleasonator.png"]
  ],
  "pubkey": "79c2cae114ea28a981e7559b4fe7854a473521a8d22a66bbab9fa248eb820ff6",
  "created_at": 1682630000
 }
 ```
--- a/31.md
+++ b/31.md
@ -0,0 +1,15 @@
 NIP-31
 ======
 Dealing with unknown event kinds
 --------------------------------
 `draft` `optional` `author:pablof7z` `author:fiatjaf`
 When creating a new custom event kind that is part of a custom protocol and isn't meant to be read as text (like `kind:1`), clients should use an `alt` tag to write a short human-readable plaintext summary of what that event is about.
 The intent is that social clients, used to display only `kind:1` notes, can still show something in case a custom event pops up in their timelines. The content of the `alt` tag should provide enough context for a user that doesn't know anything about this event kind to understand what it is.
 These clients that only know `kind:1` are not expected to ask relays for events of different kinds, but users could still reference these weird events on their notes, and without proper context these could be nonsensical notes. Having the fallback text makes that situation much better -- even if only for making the user aware that they should try to view that custom event elsewhere.
 `kind:1`-centric clients can make interacting with these event kinds more functional by supporting [NIP-89](https://github.com/nostr-protocol/nips/blob/master/89.md).
--- a/32.md
+++ b/32.md
@ -0,0 +1,126 @@
 NIP-32
 ======
 Labeling
 ---------
 `draft` `optional` `author:staab` `author:gruruya` `author:s3x-jay`
 A label is a `kind 1985` event that is used to label other entities. This supports a number of use cases, from distributed moderation and content recommendations to reviews and ratings.
 Label Target
 ----
 The label event MUST include one or more tags representing the object or objects being
 labeled: `e`, `p`, `a`, `r`, or `t` tags. This allows for labeling of events, people, relays,
 or topics respectively. As with NIP-01, a relay hint SHOULD be included when using `e` and
 `p` tags.
 Label Tag
 ----
 This NIP introduces a new tag `l` which denotes a label, and a new `L` tag which denotes a label namespace.
 A label MUST include a mark matching an `L` tag. `L` tags refer to a tag type within nostr, or a nomenclature
 external to nostr defined either formally or by convention. Any string can be a namespace, but publishers SHOULD
 ensure they are unambiguous by using a well-defined namespace (such as an ISO standard) or reverse domain name notation.
 Namespaces starting with `#` indicate that the label target should be associated with the label's value.
 This is a way of attaching standard nostr tags to events, pubkeys, relays, urls, etc.
 Some examples:
 - `["l", "footstr", "#t"]` - the publisher thinks the given entity should have the `footstr` topic applied.
 - `["l", "<pubkey>", "#p"]` - the publisher thinks the given entity is related to `<pubkey>`
 - `["l", "IT-MI", "ISO-3166-2"]` - Milano, Italy using ISO 3166-2.
 - `["l", "VI-hum", "com.example.ontology"]` - Violence toward a human being as defined by ontology.example.com.
 `L` tags containing the label namespaces MUST be included in order to support searching by
 namespace rather than by a specific tag. The special `ugc` ("user generated content") namespace
 MAY be used when the label content is provided by an end user.
 `l` and `L` tags MAY be added to other event kinds to support self-reporting. For events
 with a kind other than 1985, labels refer to the event itself.
 Label Annotations
 -----
 A label tag MAY include a 4th positional element detailing extra metadata about the label in question. This string
 should be a json-encoded object. Any key MAY be used, but the following are recommended:
 - `quality` may have a value of 0 to 1. This allows for an absolute, granular scale that can be represented in any way (5 stars, color scale, etc).
 - `confidence` may have a value of 0 to 1. This indicates the certainty which the author has about their rating.
 - `context` may be an array of urls (including NIP-21 urls) indicating other context that should be considered when interpreting labels.
 Content
 -------
 Labels should be short, meaningful strings. Longer discussions, such as for a review, or an
 explanation of why something was labeled the way it was, should go in the event's `content` field.
 Example events
 --------------
 A suggestion that multiple pubkeys be associated with the `permies` topic.
 ```json
 {
  "kind": 1985,
  "tags": [
    ["L", "#t"],
    ["l", "permies", "#t"],
    ["p", <pubkey1>, <relay_url>],
    ["p", <pubkey2>, <relay_url>]
  ],
  "content": "",
  ...
 }
 ```
 A review of a relay.
 ```json
 {
  "kind": 1985,
  "tags": [
    ["L", "com.example.ontology"],
    ["l", "relay/review", "com.example.ontology", "{\"quality\": 0.1}"],
    ["r", <relay_url>]
  ],
  "content": "This relay is full of mean people.",
  ...
 }
 ```
 Publishers can self-label by adding `l` tags to their own non-1985 events.
 ```json
 {
  "kind": 1,
  "tags": [
    ["L", "com.example.ontology"],
    ["l", "IL-frd", "com.example.ontology"]
  ],
  "content": "Send me 100 sats and I'll send you 200 back",
  ...
 }
 ```
 Other Notes
 -----------
 When using this NIP to bulk-label many targets at once, events may be deleted and a replacement
 may be published. We have opted not to use parameterizable/replaceable events for this due to the
 complexity in coming up with a standard `d` tag. In order to avoid ambiguity when querying,
 publishers SHOULD limit labeling events to a single namespace.
 Before creating a vocabulary, explore how your use case may have already been designed and
 imitate that design if possible. Reverse domain name notation is encouraged to avoid
 namespace clashes, but for the sake of interoperability all namespaces should be
 considered open for public use, and not proprietary. In other words, if there is a
 namespace that fits your use case, use it even if it points to someone else's domain name.
 Vocabularies MAY choose to fully qualify all labels within a namespace (for example,
 `["l", "com.example.vocabulary:my-label"]`. This may be preferred when defining more
 formal vocabularies that should not be confused with another namespace when querying
 without an `L` tag. For these vocabularies, all labels SHOULD include the namespace
 (rather than mixing qualified and unqualified labels).
--- a/33.md
+++ b/33.md
@ -10,12 +10,16 @@ This NIP adds a new event range that allows for replacement of events that have
 Implementation
 --------------
-The value of a tag is defined as the first parameter of a tag after the tag name.
+The value of a tag can be any string and is defined as the first parameter of a tag after the tag name.
 A *parameterized replaceable event* is defined as an event with a kind `30000 <= n < 40000`.
 Upon a parameterized replaceable event with a newer timestamp than the currently known latest
-replaceable event with the same kind and first `d` tag value being received, the old event
+replaceable event with the same kind, author and first `d` tag value being received, the old event
-SHOULD be discarded and replaced with the newer event.
+SHOULD be discarded, effectively replacing what gets returned when querying for
 `author:kind:d-tag` tuples.
 If two events have the same timestamp, the event with the lowest id (first in lexical order) SHOULD be retained, and the other discarded.
 A missing or a `d` tag with no value should be interpreted equivalent to a `d` tag with the
 value as an empty string. Events from the same author with any of the following `tags`
 replace each other:
@ -26,7 +30,7 @@ replace each other:
 * `"tags":[["d",""],["d","not empty"]]`: only first `d` tag is considered
 * `"tags":[["d"],["d","some value"]]`: only first `d` tag is considered
 * `"tags":[["e"]]`: same as no tags
-* `"tags":[["d","test","1"]]`: only the value is considered (`test`)
+* `"tags":[["d","","1"]]`: only the first value is considered (`""`)
 Clients SHOULD NOT use `d` tags with multiple values and SHOULD include the `d` tag even if it has no value to allow querying using the `#d` filter.
--- a/36.md
+++ b/36.md
@ -9,6 +9,9 @@ Sensitive Content / Content Warning
 The `content-warning` tag enables users to specify if the event's content needs to be approved by readers to be shown.
 Clients can hide the content until the user acts on it.
 `l` and `L` tags MAY be also be used as defined in [NIP-32](32.md) with the `content-warning` or other namespace to support
 further qualification and querying.
 #### Spec
 ```
@ -26,6 +29,10 @@ options:
    "kind": 1,
    "tags": [
      ["t", "hastag"],
      ["L", "content-warning"],
      ["l", "reason", "content-warning"],
      ["L", "social.nos.ontology"],
      ["l", "NS-nud", "social.nos.ontology"],
      ["content-warning", "reason"] /* reason is optional */
    ],
    "content": "sensitive content with #hastag\n",
--- a/39.md
+++ b/39.md
@ -0,0 +1,66 @@
 NIP-39
 ======
 External Identities in Profiles
 -------------------------------
 `draft` `optional` `author:pseudozach` `author:Semisol`
 ## 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.
 ## `i` tag on a metadata event
 A new optional `i` tag is introduced for `kind 0` metadata event contents in addition to name, about, picture fields as included in [NIP-01](https://github.com/nostr-protocol/nips/blob/master/01.md):
 ```json
 {
    "id": <id>,
    "pubkey": <pubkey>,
    ...
    "tags": [
        ["i", "github:semisol", "9721ce4ee4fceb91c9711ca2a6c9a5ab"],
        ["i", "twitter:semisol_public", "1619358434134196225"],
        ["i", "mastodon:bitcoinhackers.org/@semisol", "109775066355589974"]
        ["i", "telegram:1087295469", "nostrdirectory/770"]
    ]
 }
 ```
 An `i` tag will 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.
 Clients SHOULD process any `i` tags with more than 2 values for future extensibility.  
 Identity provider names SHOULD only include `a-z`, `0-9` and the characters `._-/` and MUST NOT include `:`.  
 Identity names SHOULD be normalized if possible by replacing uppercase letters with lowercase letters, and if there are multiple aliases for an entity the primary one should be used.  
 ## Claim types
 ### `github`
 Identity: A GitHub username.
 Proof: A GitHub Gist ID. This Gist should be created by `<identity>` with a single file that has the text `Verifying that I control the following Nostr public key: <npub encoded public key>`.  
 This can be located at `https://gist.github.com/<identity>/<proof>`.
 ### `twitter`
 Identity: A Twitter username.
 Proof: A Tweet ID. The tweet should be posted by `<identity>` and have the text `Verifying my account on nostr My Public Key: "<npub encoded public key>"`.  
 This can be located at `https://twitter.com/<identity>/status/<proof>`.
 ### `mastodon`
 Identity: A Mastodon instance and username in the format `<instance>/@<username>`.
 Proof: A Mastodon post ID. This post should be published by `<username>@<instance>` and have the text `Verifying that I control the following Nostr public key: "<npub encoded public key>"`.
 This can be located at `https://<identity>/<proof>`.
 ### `telegram`
 Identity: A Telegram user ID.
 Proof: A string in the format `<ref>/<id>` which points to a message published in the public channel or group with name `<ref>` and message ID `<id>`. This message should be sent by user ID `<identity>` and have the text `Verifying that I control the following Nostr public key: "<npub encoded public key>"`.  
 This can be located at `https://t.me/<proof>`.
--- a/40.md
+++ b/40.md
@ -43,7 +43,7 @@ Clients SHOULD ignore events that have expired.
 Relay Behavior
 --------------
-Relays MAY NOT delete an expired message immediately on expiration and MAY persist them indefinitely.  
+Relays MAY NOT delete expired messages immediately on expiration and MAY persist them indefinitely.  
 Relays SHOULD NOT send expired events to clients, even if they are stored.  
 Relays SHOULD drop any events that are published to them if they are expired.  
 An expiration timestamp does not affect storage of ephemeral events.
--- a/45.md
+++ b/45.md
@ -0,0 +1,39 @@
 NIP-45
 ======
 Event Counts
 --------------
 `draft` `optional` `author:staab`
 Relays may support the verb `COUNT`, which provides a mechanism for obtaining event counts.
 ## Motivation
 Some queries a client may want to execute against connected relays are prohibitively expensive, for example, in order to retrieve follower counts for a given pubkey, a client must query all kind-3 events referring to a given pubkey only to count them. The result may be cached, either by a client or by a separate indexing server as an alternative, but both options erode the decentralization of the network by creating a second-layer protocol on top of Nostr.
 ## 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.
 ```
 ["COUNT", <subscription_id>, <filters JSON>...]
 ```
 Counts are returned using a `COUNT` response in the form `{"count": <integer>}`. Relays may use probabilistic counts to reduce compute requirements.
 ```
 ["COUNT", <subscription_id>, {"count": <integer>}]
 ```
 Examples:
 ```
 # Followers count
 ["COUNT", <subscription_id>, {"kinds": [3], "#p": [<pubkey>]}]
 ["COUNT", <subscription_id>, {"count": 238}]
 # Count posts and reactions
 ["COUNT", <subscription_id>, {"kinds": [1, 7], "authors": [<pubkey>]}]
 ["COUNT", <subscription_id>, {"count": 5}]
 ```
--- a/46.md
+++ b/46.md
@ -67,7 +67,7 @@ These are mandatory methods the remote signer app MUST implement:
  - result `pubkey` 
 - **sign_event**
  - params [`event`]
-  - result `signature` 
+  - result `event_with_signature` 
 #### optional
@ -151,7 +151,7 @@ The `content` field contains encrypted message as specified by [NIP04](https://g
 1. The **App** will send a message to the **Signer** with a `sign_event` request along with the **event** to be signed
 2. The **Signer** will show a popup to the user to inspect the event and sign it
-3. The **Signer** will send back a message with the schnorr `signature` of the event as a response to the `sign_event` request
+3. The **Signer** will send back a message with the event including the `id` and the schnorr `signature` as a response to the `sign_event` request
 ### Delegate
--- a/47.md
+++ b/47.md
@ -0,0 +1,137 @@
 NIP-47
 ======
 Nostr Wallet Connect
 --------------------
 `draft` `optional` `author:kiwiidb` `author:bumi` `author:semisol` `author:vitorpamplona`
 ## Rationale
 This NIP describes a way for clients to access a remote Lightning wallet through a standardized protocol. Custodians may implement this, or the user may run a bridge that bridges their wallet/node and the Nostr Wallet Connect protocol.
 ## Terms
 * **client**: Nostr app on any platform that wants to pay Lightning invoices.
 * **user**: The person using the **client**, and want's to connect their wallet app to their **client**.
 * **wallet service**: Nostr app that typically runs on an always-on computer (eg. in the cloud or on a Raspberry Pi).  This app has access to the APIs of the wallets it serves.
 ## Theory of Operation
 1. **Users** who which to use this NIP to send lightning payments to other nostr users must first acquire a special "connection" URI from their NIP-47 compliant wallet application.  The wallet application may provide this URI using a QR screen, or a pasteable string, or some other means. 
 2. The **user** should then copy this URI into their **client(s)** by pasting, or scanning the QR, etc.  The **client(s)** should save this URI and use it later whenever the **user** makes a payment.  The **client** should then request an `info` (13194) event from the relay(s) specified in the URI.  The **wallet service** will have sent that event to those relays earlier, and the relays will hold it as a replaceable event.  
 3. When the **user** initiates a payment their nostr **client** create a `pay_invoice` request, encrypts it using a token from the URI, and sends it (kind 23194) to the relay(s) specified in the connection URI.  The **wallet service** will be listening on those relays and will decrypt the request and then contact the **user's** wallet application to send the payment.  The **wallet service** will know how to talk to the wallet application because the connection URI specified relay(s) that have access to the wallet app API.  
 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.  
 ## Events
 There are three event kinds:
 - `NIP-47 info event`: 13194
 - `NIP-47 request`: 23194
 - `NIP-47 response`: 23195
 The info event should be a replaceable event that is published by the **wallet service** on the relay to indicate which commands it supports. The content should be
 a plaintext string with the supported commands, space-separated, eg. `pay_invoice get_balance`. Only the `pay_invoice` command is described in this NIP, but other commands might be defined in different NIPs.
 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 **user** if this is a response. The response event SHOULD contain an `e` tag with the id of the request event it is responding to.
 The content of requests and responses is encrypted with [NIP04](https://github.com/nostr-protocol/nips/blob/master/04.md), and is a JSON-RPCish object with a semi-fixed structure:
 Request:
 ```jsonc
 {
    "method": "pay_invoice", // method, string
    "params": { // params, object
        "invoice": "lnbc50n1..." // command-related data
    }
 }
 ```
 Response:
 ```jsonc
 {
    "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
    }
 }
 ```
 The `result_type` field MUST contain the name of the method that this event is responding to.
 The `error` field MUST contain a `message` field with a human readable error message and a `code` field with the error code if the command was not successful.
 If the command was successful, the `error` field must be null.
 ### 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.
 - `INSUFFICIENT_BALANCE`: The wallet does not have enough funds to cover a fee reserve or the payment amount.
 - `QUOTA_EXCEEDED`: The wallet has exceeded its spending quota.
 - `RESTRICTED`: This public key is not allowed to do this operation.
 - `UNAUTHORIZED`: This public key has no wallet connected.
 - `INTERNAL`: An internal error.
 - `OTHER`: Other error.
 ## Nostr Wallet Connect URI
 **client** discovers **wallet service** by scanning a QR code, handling a deeplink or pasting in a URI.
 The **wallet service** generates this connection URI with protocol `nostr+walletconnect:` and base path it's hex-encoded `pubkey` with the following query string parameters: 
 - `relay` Required. URL of the relay where the **wallet service** is connected and will be listening for events. May be more than one.
 - `secret` Required. 32-byte randomly generated hex encoded string. The **client** MUST use this to sign events and encrypt payloads when communicating with the **wallet service**.
    - Authorization does not require passing keys back and forth.
    - The user can have different keys for different applications. Keys can be revoked and created at will and have arbitrary constraints (eg. budgets).
    - The key is harder to leak since it is not shown to the user and backed up.
    - It improves privacy because the user's main key would not be linked to their payments.
 - `lud16` Recommended. A lightning address that clients can use to automatically setup the `lud16` field on the user's profile if they have none configured.
 The **client** should then store this connection and use it when the user wants to perform actions like paying an invoice. Due to this NIP using ephemeral events, it is recommended to pick relays that do not close connections on inactivity to not drop events.
 ### Example connection string
 ```sh
 nostr+walletconnect:b889ff5b1513b641e2a139f661a661364979c5beee91842f8f0ef42ab558e9d4?relay=wss%3A%2F%2Frelay.damus.io&secret=71a8c14c1407c113601079c4302dab36460f0ccd0ad506f1f2dc73b5100e4f3c
 ```
 ## Commands
 ### `pay_invoice`
 Description: Requests payment of an invoice.
 Request:
 ```jsonc
 {
    "method": "pay_invoice",
    "params": {
        "invoice": "lnbc50n1..." // bolt11 invoice
    }
 }
 ```
 Response:
 ```jsonc
 {
    "result_type": "pay_invoice",
    "result": { 
        "preimage": "0123456789abcdef..." // preimage of the payment
    }
 }
 ```
 Errors:
 - `PAYMENT_FAILED`: The payment failed. This may be due to a timeout, exhausting all routes, insufficient capacity or similar.
 ## 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.
 1. **client** sends an event to the **wallet service** service with kind `23194`. The content is a `pay_invoice` request. The private key is the secret from the connection string above.
 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.
 ## 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.
--- a/51.md
+++ b/51.md
@ -0,0 +1,112 @@
 NIP-51
 ======
 Lists
 -------------------------
 `draft` `optional` `author:fiatjaf` `author:arcbtc` `author:monlovesmango` `author:eskema` `depends:33`
 A "list" event is defined as having a list of public and/or private tags. Public tags will be listed in the event `tags`. Private tags will be encrypted in the event `content`. Encryption for private tags will use [NIP-04 - Encrypted Direct Message](04.md) encryption, using the list author's private and public key for the shared secret. A distinct event kind should be used for each list type created.
 If a list type should only be defined once per user (like the 'Mute' list), the list type's events should follow the specification for [NIP-16 - Replaceable Events](16.md). These lists may be referred to as 'replaceable lists'.
 Otherwise, the list type's events should follow the specification for [NIP-33 - Parameterized Replaceable Events](33.md), where the list name will be used as the 'd' parameter. These lists may be referred to as 'parameterized replaceable lists'.
 ## Replaceable List Event Example
 Lets say a user wants to create a 'Mute' list and has keys:
 ```
 priv: fb505c65d4df950f5d28c9e4d285ee12ffaf315deef1fc24e3c7cd1e7e35f2b1
 pub: b1a5c93edcc8d586566fde53a20bdb50049a97b15483cb763854e57016e0fa3d
 ```
 The user wants to publicly include these users:
 ```json
 ["p", "3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d"],
 ["p", "32e1827635450ebb3c5a7d12c1f8e7b2b514439ac10a67eef3d9fd9c5c68e245"]
 ```
 and privately include these users (below is the JSON that would be encrypted and placed in the event content):
 ```json
 [
    ["p", "9ec7a778167afb1d30c4833de9322da0c08ba71a69e1911d5578d3144bb56437"],
    ["p", "8c0da4862130283ff9e67d889df264177a508974e2feb96de139804ea66d6168"]
 ]
 ```
 Then the user would create a 'Mute' list event like below:
 ```json
 {
  "kind": 10000,
  "tags": [
    ["p", "3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d"],
    ["p", "32e1827635450ebb3c5a7d12c1f8e7b2b514439ac10a67eef3d9fd9c5c68e245"],
  ],
  "content": "VezuSvWak++ASjFMRqBPWS3mK5pZ0vRLL325iuIL4S+r8n9z+DuMau5vMElz1tGC/UqCDmbzE2kwplafaFo/FnIZMdEj4pdxgptyBV1ifZpH3TEF6OMjEtqbYRRqnxgIXsuOSXaerWgpi0pm+raHQPseoELQI/SZ1cvtFqEUCXdXpa5AYaSd+quEuthAEw7V1jP+5TDRCEC8jiLosBVhCtaPpLcrm8HydMYJ2XB6Ixs=?iv=/rtV49RFm0XyFEwG62Eo9A==",
  ...other fields
 }
 ```
 ## Parameterized Replaceable List Event Example
 Lets say a user wants to create a 'Categorized People' list of `nostr` people and has keys:
 ```
 priv: fb505c65d4df950f5d28c9e4d285ee12ffaf315deef1fc24e3c7cd1e7e35f2b1
 pub: b1a5c93edcc8d586566fde53a20bdb50049a97b15483cb763854e57016e0fa3d
 ```
 The user wants to publicly include these users:
 ```json
 ["p", "3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d"],
 ["p", "32e1827635450ebb3c5a7d12c1f8e7b2b514439ac10a67eef3d9fd9c5c68e245"]
 ```
 and privately include these users (below is the JSON that would be encrypted and placed in the event content):
 ```json
 [
    ["p", "9ec7a778167afb1d30c4833de9322da0c08ba71a69e1911d5578d3144bb56437"],
    ["p", "8c0da4862130283ff9e67d889df264177a508974e2feb96de139804ea66d6168"]
 ]
 ```
 Then the user would create a 'Categorized People' list event like below:
 ```json
 {
  "kind": 30000,
  "tags": [
    ["d", "nostr"],
    ["p", "3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d"],
    ["p", "32e1827635450ebb3c5a7d12c1f8e7b2b514439ac10a67eef3d9fd9c5c68e245"],
  ],
  "content": "VezuSvWak++ASjFMRqBPWS3mK5pZ0vRLL325iuIL4S+r8n9z+DuMau5vMElz1tGC/UqCDmbzE2kwplafaFo/FnIZMdEj4pdxgptyBV1ifZpH3TEF6OMjEtqbYRRqnxgIXsuOSXaerWgpi0pm+raHQPseoELQI/SZ1cvtFqEUCXdXpa5AYaSd+quEuthAEw7V1jP+5TDRCEC8jiLosBVhCtaPpLcrm8HydMYJ2XB6Ixs=?iv=/rtV49RFm0XyFEwG62Eo9A==",
  ...other fields
 }
 ```
 ## List Event Kinds
 | kind   | list type               |
 | ------ | ----------------------- |
 | 10000  | Mute                    |
 | 10001  | Pin                     |
 | 30000  | Categorized People      |
 | 30001  | Categorized Bookmarks   |
 ### Mute List
 An event with kind `10000` is defined as a replaceable list event for listing content a user wants to mute. Any standardized tag can be included in a Mute List.
 ### Pin List
 An event with kind `10001` is defined as a replaceable list event for listing content a user wants to pin. Any standardized tag can be included in a Pin List.
 ### Categorized People List
 An event with kind `30000` is defined as a parameterized replaceable list event for categorizing people. The 'd' parameter for this event holds the category name of the list. The tags included in these lists MUST follow the format of kind 3 events as defined in [NIP-02 - Contact List and Petnames](02.md).
 ### Categorized Bookmarks List
 An event with kind `30001` is defined as a parameterized replaceable list event for categorizing bookmarks. The 'd' parameter for this event holds the category name of the list. Any standardized tag can be included in a Categorized Bookmarks List.
--- a/56.md
+++ b/56.md
@ -32,6 +32,9 @@ being reported, which consists of the following report types:
 Some report tags only make sense for profile reports, such as `impersonation`
 `l` and `L` tags MAY be also be used as defined in [NIP-32](32.md) to support
 further qualification and querying.
 Example events
 --------------
@ -39,7 +42,9 @@ Example events
 {
  "kind": 1984,
  "tags": [
-    [ "p", <pubkey>, "nudity"]
+    ["p", <pubkey>, "nudity"]
    ["L", "social.nos.ontology"],
    ["l", "NS-nud", "social.nos.ontology"],
  ],
  "content": "",
  ...
@ -48,8 +53,8 @@ Example events
 {
  "kind": 1984,
  "tags": [
-    [ "e", <eventId>, "illegal"],
+    ["e", <eventId>, "illegal"],
-    [ "p", <pubkey>]
+    ["p", <pubkey>]
  ],
  "content": "He's insulting the king!",
  ...
@ -58,8 +63,8 @@ Example events
 {
  "kind": 1984,
  "tags": [
-    [ "p", <impersonator pubkey>, "impersonation"],
+    ["p", <impersonator pubkey>, "impersonation"],
-    [ "p", <victim pubkey>]
+    ["p", <victim pubkey>]
  ],
  "content": "Profile is imitating #[1]",
  ...
--- a/57.md
+++ b/57.md
@ -6,69 +6,139 @@ Lightning Zaps
 `draft` `optional` `author:jb55` `author:kieran`
-This NIP defines a new note type called a lightning zap of kind `9735`. These represent paid lightning invoice receipts sent by a lightning node called the `zapper`. We also define another note type of kind `9734` which are `zap request` notes, which will be described in this document.
+This NIP defines two new event types for recording lightning payments between users. `9734` is a `zap request`, representing a payer's request to a recipient's lightning wallet for an invoice. `9735` is a `zap receipt`, representing the confirmation by the recipient's lightning wallet that the invoice issued in response to a `zap request` has been paid.
 Having lightning receipts on nostr allows clients to display lightning payments from entities on the network. These can be used for fun or for spam deterrence.
 ## Definitions
 `zapper` - the lightning node or service that sends zap notes (kind `9735`)
 `zap request` - a note of kind `9734` created by the person zapping
 `zap invoice` - the bolt11 invoice fetched from a custom lnurl endpoint which contains a `zap request` note
 ## Protocol flow
-### Client side
+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.
 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.
 5. The recipient's lnurl server will receive this `zap request` and validate it. See Appendix C for details on how to properly configure an lnurl server to support zaps, and Appendix D for details on how to validate the `nostr` query parameter.
 6. If the `zap request` is valid, the server should fetch a description hash invoice where the description is this `zap request` note and this note only. No additional lnurl metadata is included in the description. This will be returned in the response according to [LUD06](https://github.com/lnurl/luds/blob/luds/06.md).
 7. On receiving the invoice, the client MAY pay it or pass it to an app that can pay the invoice.
 8. Once the invoice is paid, the recipient's lnurl server MUST generate a `zap receipt` as described in Appendix E, and publish it to the `relays` specified in the `zap request`.
 9. Clients MAY fetch `zap receipt`s on posts and profiles, but MUST authorize their validity as described in Appendix F. If the `zap request` note contains a non-empty `content`, it may display a zap comment. Generally clients should show users the `zap request` note, and use the `zap receipt` to show "zap authorized by ..." but this is optional.
-1. Calculate the lnurl pay request url for a user from the lud06 or lud16 field on their profile
+## Reference and examples
-2. Fetch the lnurl pay request static endpoint (`https://host.com/.well-known/lnurlp/user`) and gather the `allowsNostr` and `nostrPubkey` fields. If `allowsNostr` exists and it is `true`, and if `nostrPubkey` exists and is a valid BIP 340 public key, associate this information with the user. The `nostrPubkey` is the `zapper`'s pubkey, and it is used to authorize zaps sent to that user.
+### Appendix A: Zap Request Event
-3. Clients may choose to display a lightning zap button on each post or on the users profile, if the user's lnurl pay request endpoint supports nostr, the client SHOULD generate a `zap invoice` instead of a normal lnurl invoice.
+A `zap request` is an event of kind `9734` that is _not_ published to relays, but is instead sent to a recipient's lnurl pay `callback` url. This event's `content` MAY be an optional message to send along with the payment. The event MUST include the following tags:
-4. To generate a `zap invoice`, call the `callback` url with `amount` set to the milli-satoshi amount value. A `nostr` querystring value MUST be set as well. It is a uri-encoded `zap request` note signed by the user's key. The `zap request` note contains an `e` tag of the note it is zapping, and a `p` tag of the target user's pubkey. The `e` tag is optional which allows profile tipping. An optional `a` tag allows tipping parameterized replaceable events such as NIP-23 long-form notes. The `zap request` note must also have a `relays` tag, which is gathered from the user's configured relays. The `zap request` note SHOULD contain an `amount` tag, which is the milli-satoshi value of the zap which clients SHOULD verify being equal to the amount of the invoice. The `content` MAY be an additional comment from the user which can be displayed when listing zaps on posts and profiles.
+- `relays` is a list of relays the recipient's wallet should publish its `zap receipt` to. Note that relays should not be nested in an additional list, but should be included as shown in the example below.
 - `amount` is the amount in _millisats_ the sender intends to pay, formatted as a string. This is recommended, but optional.
 - `lnurl` is the lnurl pay url of the recipient, encoded using bech32 with the prefix `lnurl`. This is recommended, but optional.
 - `p` is the hex-encoded pubkey of the recipient.
-5. Pay this invoice or pass it to an app that can pay the invoice. Once it's paid, a `zap note` will be created by the `zapper`.
+In addition, the event MAY include the following tags:
-### LNURL Server side
+- `e` is an optional hex-encoded event id. Clients MUST include this if zapping an event rather than a person.
 - `a` is an optional NIP-33 event coordinate that allows tipping parameterized replaceable events such as NIP-23 long-form notes.
 Example:
 ```json
 {
  "kind": 9734,
  "content": "Zap!",
  "tags": [
    ["relays", "wss://nostr-pub.wellorder.com"],
    ["amount", "21000"],
    ["lnurl", "lnurl1dp68gurn8ghj7um5v93kketj9ehx2amn9uh8wetvdskkkmn0wahz7mrww4excup0dajx2mrv92x9xp"],
    ["p", "04c915daefee38317fa734444acee390a8269fe5810b2241e5e6dd343dfbecc9"],
    ["e", "9ae37aa68f48645127299e9453eb5d908a0cbb6058ff340d528ed4d37c8994fb"]
  ],
  "pubkey": "97c70a44366a6535c145b333f973ea86dfdc2d7a99da618c40c64705ad98e322",
  "created_at": 1679673265,
  "id": "30efed56a035b2549fcaeec0bf2c1595f9a9b3bb4b1a38abaf8ee9041c4b7d93",
  "sig": "f2cb581a84ed10e4dc84937bd98e27acac71ab057255f6aa8dfa561808c981fe8870f4a03c1e3666784d82a9c802d3704e174371aa13d63e2aeaf24ff5374d9d"
 }
 ```
 ### Appendix B: Zap Request HTTP Request
 A signed `zap request` event is not published, but is instead sent using a HTTP GET request to the recipient's `callback` url, which was provided by the recipient's lnurl pay endpoint. This request should have the following query parameters defined:
 - `amount` is the amount in _millisats_ the sender intends to pay
 - `nostr` is the `9734` `zap request` event, JSON encoded then URI encoded
 - `lnurl` is the lnurl pay url of the recipient, encoded using bech32 with the prefix `lnurl`
 This request should return a JSON response with a `pr` key, which is the invoice the sender must pay to finalize his zap. Here is an example flow:
 ```javascript
 const senderPubkey // The sender's pubkey
 const recipientPubkey = // The recipient's pubkey
 const callback = // The callback received from the recipients lnurl pay endpoint
 const lnurl = // The recipient's lightning address, encoded as a lnurl
 const sats = 21
 const amount = sats * 1000
 const relays = ['wss://nostr-pub.wellorder.net']
 const event = encodeURI(JSON.stringify(await signEvent({
  kind: [9734],
  content: "",
  pubkey: senderPubkey,
  created_at: Math.round(Date.now() / 1000),
  tags: [
    ["relays", ...relays],
    ["amount", amount.toString()],
    ["lnurl", lnurl],
    ["p", recipientPubkey],
  ],
 })))
 const {pr: invoice} = await fetchJson(`${callback}?amount=${amount}&nostr=${event}&lnurl=${lnurl}`)
 ```
 ### Appendix C: LNURL Server Configuration
 The lnurl server will need some additional pieces of information so that clients can know that zap invoices are supported:
-1. Add a `nostrPubkey` to the lnurl-pay static endpoint `/.well-known/lnurlp/user`, where `nostrPubkey` is the nostr pubkey of the `zapper`, the entity that creates zap notes. Clients will use this to authorize zaps.
+1. Add a `nostrPubkey` to the lnurl-pay static endpoint `/.well-known/lnurlp/<user>`, where `nostrPubkey` is the nostr pubkey your server will use to sign `zap receipt` events. Clients will use this to validate `zap receipt`s.
 2. Add an `allowsNostr` field and set it to true.
-3. In the lnurl-pay callback URL, watch for a `nostr` querystring, where the contents of the note is a uri-encoded `zap request` JSON.
+### Appendix D: LNURL Server Zap Request Validation
-4. If present, the zap request note must be validated:
+When a client sends a `zap request` event to a server's lnurl-pay callback URL, there will be a `nostr` query parameter whose value is that event which is URI- and JSON-encoded. If present, the `zap request` event must be validated in the following ways:
-	a. It MUST have a valid nostr signature
+1. It MUST have a valid nostr signature
 2. It MUST have tags
 3. It MUST have only one `p` tag
 4. It MUST have 0 or 1 `e` tags
 5. There should be a `relays` tag with the relays to send the `zap receipt` to.
 6. If there is an `amount` tag, it MUST be equal to the `amount` query parameter.
 7. If there is an `a` tag, it MUST be a valid NIP-33 event coordinate
-	b. It MUST have tags
+The event MUST then be stored for use later, when the invoice is paid.
-	c. It MUST have at least one p-tag
+### Appendix E: Zap Receipt Event
-	d. It MUST have either 0 or 1 e-tag
+A `zap receipt` is created by a lightning node when an invoice generated by a `zap request` is paid. `Zap receipt`s are only created when the invoice description (committed to the description hash) contains a `zap request` note.
-	e. There should be a `relays` tag with the relays to send the `zap` note to.
+When receiving a payment, the following steps are executed:
-	f. If there is an `amount` tag, it MUST be equal to the `amount` query parameter.
+1. Get the description for the invoice. This needs to be saved somewhere during the generation of the description hash invoice. It is saved automatically for you with CLN, which is the reference implementation used here.
 2. Parse the bolt11 description as a JSON nostr event. This SHOULD be validated based on the requirements in Appendix D, either when it is received, or before the invoice is paid.
 3. Create a nostr event of kind `9735` as described below, and publish it to the `relays` declared in the `zap request`.
-	g. If there is an `a` tag, it MUST be a valid NIP-33 event coordinate
+The following should be true of the `zap receipt` event:
-5. If valid, fetch a description hash invoice where the description is this note and this note only. No additional lnurl metadata is included in the description.
+- The content SHOULD be empty.
 - The `created_at` date SHOULD be set to the invoice `paid_at` date for idempotency.
 - `tags` MUST include the `p` tag AND optional `e` tag from the `zap request`.
 - The `zap receipt` MUST have a `bolt11` tag containing the description hash bolt11 invoice.
 - The `zap receipt` MUST contain a `description` tag which is the JSON-encoded invoice description.
 - `SHA256(description)` MUST match the description hash in the bolt11 invoice.
 - The `zap receipt` MAY contain a `preimage` tag to match against the payment hash of the bolt11 invoice. This isn't really a payment proof, there is no real way to prove that the invoice is real or has been paid. You are trusting the author of the `zap receipt` for the legitimacy of the payment.
-At this point, the lightning node is ready to send the zap note once payment is received.
+The `zap receipt` is not a proof of payment, all it proves is that some nostr user fetched an invoice. The existence of the `zap receipt` implies the invoice as paid, but it could be a lie given a rogue implementation.
-## The zap note
+A reference implementation for a zap-enabled lnurl server can be found [here](https://github.com/jb55/cln-nostr-zapper).
-Zap notes are created by a lightning node reacting to paid invoices. Zap notes are only created when the invoice description (committed to the description hash) contains a `zap request` note.
+Example `zap receipt`:
 Example zap note:
 ```json
 {
@ -77,74 +147,37 @@ Example zap note:
    "created_at": 1674164545,
    "kind": 9735,
    "tags": [
-      [
+      ["p", "32e1827635450ebb3c5a7d12c1f8e7b2b514439ac10a67eef3d9fd9c5c68e245"],
-        "p",
+      ["e", "3624762a1274dd9636e0c552b53086d70bc88c165bc4dc0f9e836a1eaf86c3b8"],
-        "32e1827635450ebb3c5a7d12c1f8e7b2b514439ac10a67eef3d9fd9c5c68e245"
+      ["bolt11", "lnbc10u1p3unwfusp5t9r3yymhpfqculx78u027lxspgxcr2n2987mx2j55nnfs95nxnzqpp5jmrh92pfld78spqs78v9euf2385t83uvpwk9ldrlvf6ch7tpascqhp5zvkrmemgth3tufcvflmzjzfvjt023nazlhljz2n9hattj4f8jq8qxqyjw5qcqpjrzjqtc4fc44feggv7065fqe5m4ytjarg3repr5j9el35xhmtfexc42yczarjuqqfzqqqqqqqqlgqqqqqqgq9q9qxpqysgq079nkq507a5tw7xgttmj4u990j7wfggtrasah5gd4ywfr2pjcn29383tphp4t48gquelz9z78p4cq7ml3nrrphw5w6eckhjwmhezhnqpy6gyf0"],
-      ],
+      ["description", "{\"pubkey\":\"32e1827635450ebb3c5a7d12c1f8e7b2b514439ac10a67eef3d9fd9c5c68e245\",\"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"]
        "e",
        "3624762a1274dd9636e0c552b53086d70bc88c165bc4dc0f9e836a1eaf86c3b8"
      ],
      [
        "bolt11",
        "lnbc10u1p3unwfusp5t9r3yymhpfqculx78u027lxspgxcr2n2987mx2j55nnfs95nxnzqpp5jmrh92pfld78spqs78v9euf2385t83uvpwk9ldrlvf6ch7tpascqhp5zvkrmemgth3tufcvflmzjzfvjt023nazlhljz2n9hattj4f8jq8qxqyjw5qcqpjrzjqtc4fc44feggv7065fqe5m4ytjarg3repr5j9el35xhmtfexc42yczarjuqqfzqqqqqqqqlgqqqqqqgq9q9qxpqysgq079nkq507a5tw7xgttmj4u990j7wfggtrasah5gd4ywfr2pjcn29383tphp4t48gquelz9z78p4cq7ml3nrrphw5w6eckhjwmhezhnqpy6gyf0"
      ],
      [
        "description",
        "{\"pubkey\":\"32e1827635450ebb3c5a7d12c1f8e7b2b514439ac10a67eef3d9fd9c5c68e245\",\"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"
      ]
    ],
    "content": "",
    "sig": "b0a3c5c984ceb777ac455b2f659505df51585d5fd97a0ec1fdb5f3347d392080d4b420240434a3afd909207195dac1e2f7e3df26ba862a45afd8bfe101c2b1cc"
  }
 ```
-* The zap note MUST have a `bolt11` tag containing the description hash bolt11 invoice.
+### Appendix F: Validating Zap Receipts
-* The zap note MUST contain a `description` tag which is the invoice description.
+A client can retrieve `zap receipt`s on events and pubkeys using a NIP-01 filter, for example `{"kinds": [9735], "#e": [...]}`. Zaps MUST be validated using the following steps:
-* `SHA256(description)` MUST match the description hash in the bolt11 invoice.
+- The `zap receipt` event's `pubkey` MUST be the same as the recipient's lnurl provider's `nostrPubkey` (retrieved in step 1 of the protocol flow).
 - The `invoiceAmount` contained in the `bolt11` tag of the `zap receipt` MUST equal the `amount` tag of the `zap request` (if present).
 - The `lnurl` tag of the `zap request` (if present) SHOULD equal the recipient's `lnurl`.
-* The zap note MAY contain a `preimage` to match against the payment hash of the bolt11 invoice. This isn't really a payment proof, there is no real way to prove that the invoice is real or has been paid. You are trusting the author of the zap note for the legitimacy of the payment.
+### Appendix G: `zap` tag on zapped event
-The zap note is not a proof of payment, all it proves is that some nostr user fetched an invoice. The existence of the zap note implies the invoice as paid, but it could be a lie given a rogue implementation.
+When an event includes a `zap` tag, clients SHOULD calculate the lnurl pay request based on its value instead of the profile's field. An optional third argument on the tag specifies the type of value, either `lud06` or `lud16`.
-
+```json
-### Creating a zap note
+{
-
+    "tags": [
-When receiving a payment, the following steps are executed:
+        [ "zap", "pablo@f7z.io", "lud16" ]
-
+    ]
-1. Get the description for the invoice. This needs to be saved somewhere during the generation of the description hash invoice. It is saved automatically for you with CLN, which is the reference implementation used here.
+}
-
+```
 2. Parse the bolt11 description as a JSON nostr note. You SHOULD check the signature of the parsed note to ensure that it is valid. This is the `zap request` note created by the entity who is zapping.
 4. The note MUST have only one `p` tag
 5. The note MUST have 0 or 1 `e` tag
 6. Create a nostr note of kind `9735` that includes the `p` tag AND optional `e` tag. The content SHOULD be empty. The created_at date SHOULD be set to the invoice paid_at date for idempotency.
 7. Send the note to the `relays` declared in the `zap request` note from the invoice description.
 A reference implementation for the zapper is here: [zapper][zapper]
 [zapper]: https://github.com/jb55/cln-nostr-zapper
 ## Client Behavior
 Clients MAY fetch zap notes on posts and profiles:
 `{"kinds": [9735], "#e": [...]}`
 To authorize these notes, clients MUST fetch the `nostrPubkey` from the users configured lightning address or lnurl and ensure that the zaps to their posts were created by this pubkey. If clients don't do this, anyone could forge unauthorized zaps.
 Once authorized, clients MAY tally zaps on posts, and list them on profiles. If the zap request note contains a non-empty `content`, it may display a zap comment. Generally clients should show users the `zap request` note, and use the `zap note` to show "zap authorized by ..." but this is optional.
 ## Future Work
-Zaps can be extended to be more private by encrypting zap request notes to the target user, but for simplicity it has been left out of this initial draft.
+Zaps can be extended to be more private by encrypting `zap request` notes to the target user, but for simplicity it has been left out of this initial draft.
--- a/78.md
+++ b/78.md
@ -8,7 +8,7 @@ Arbitrary custom app data
 The goal of this NIP is to enable [remoteStorage](https://remotestorage.io/)-like capabilities for custom applications that do not care about interoperability.
-Even though interoperability is great, some apps do not want or do not need interoperability, and it that wouldn't make sense for them. Yet Nostr can still serve as a generalized data storage for these apps in a "bring your own database" way, for example: a user would open an app and somehow input their preferred relay for storage, which would then enable these apps to store application-specific data there.
+Even though interoperability is great, some apps do not want or do not need interoperability, and it wouldn't make sense for them. Yet Nostr can still serve as a generalized data storage for these apps in a "bring your own database" way, for example: a user would open an app and somehow input their preferred relay for storage, which would then enable these apps to store application-specific data there.
 ## Nostr event
--- a/89.md
+++ b/89.md
@ -0,0 +1,116 @@
 NIP-89
 ======
 Recommended Application Handlers
 --------------------------------
 `draft` `optional` `author:pablof7z`
 This NIP describes `kind:31989` and `kind:31990`: a way to discover applications that can handle unknown event-kinds.
 ## Rationale
 Nostr's discoverability and transparent event interaction is one of its most interesting/novel mechanics.
 This NIP provides a simple way for clients to discover applications that handle events of a specific kind to ensure smooth cross-client and cross-kind interactions.
 ### Parties involved
 There are three actors to this workflow:
 * application that handles a specific event kind (note that an application doesn't necessarily need to be a distinct entity and it could just be the same pubkey as user A)
    * Publishes `kind:31990`, detailing how apps should redirect to it
 * user A, who recommends an app that handles a specific event kind
    * Publishes `kind:31989`
 * user B, who seeks a recommendation for an app that handles a specific event kind
    * Queries for `kind:31989` and, based on results, queries for `kind:31990`
 # Events
 ## Recommendation event
 ```json
 {
    "kind": 31989,
    "pubkey": <recommender-user-pubkey>,
    "tags": [
        [ "d", <supported-event-kind> ],
        [ "a", "31990:app1-pubkey:<d-identifier>", "wss://relay1", "ios" ],
        [ "a", "31990:app2-pubkey:<d-identifier>", "wss://relay2", "web" ]
    ]
 }
 ```
 The `d` tag in `kind:31989` is the supported event kind this event is recommending.
 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
 ```json
 {
    "kind": 31990,
    "pubkey": <pubkey>,
    "content": "<optional-kind:0-style-metadata>",
    "tags": [
        [ "d", <random-id> ],
        [ "k", <supported-event-kind> ],
        [ "web", "https://..../a/<bech32>", "nevent" ],
        [ "web", "https://..../p/<bech32>", "nprofile" ],
        [ "web", "https://..../e/<bech32>" ],
        [ "ios", ".../<bech32>" ]
    ]
 }
 ```
 * `content` is an optional `set_metadata`-like stringified JSON object, as described in NIP-01. This content is useful when the pubkey creating the `kind:31990` is not an application. If `content` is empty, the `kind:0` of the pubkey should be used to display application information (e.g. name, picture, web, LUD16, etc.)
 * `k` tags' value is the event kind that is supported by this `kind:31990`.
 Using a `k` tag(s) (instead of having the kind onf the NIP-33 `d` tag) provides:
    * Multiple `k` tags can exist in the same event if the application supports more than one event kind and their handler URLs are the same.
    * The same pubkey can have multiple events with different apps that handle the same event kind.
 * `bech32` in a URL MUST be replaced by clients with the NIP-19-encoded entity that should be loaded by the application.
 Multiple tags might be registered by the app, following NIP-19 nomenclature as the second value of the array.
 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.
 # User flow
 A user A who uses a non-`kind:1`-centric nostr app could choose to announce/recommend a certain kind-handler application.
 When user B sees an unknown event kind, e.g. in a social-media centric nostr client, the client would allow user B to interact with the unknown-kind event (e.g. tapping on it).
 The client MIGHT query for the user's and the user's follows handler.
 # Example
 ## User A recommends a `kind:31337`-handler
 User A might be a user of Zapstr, a `kind:31337`-centric client (tracks). Using Zapstr, user A publishes an event recommending Zapstr as a `kind:31337`-handler.
 ```json
 {
    "kind": 31989,
    "tags": [
        [ "d", "31337" ],
        [ "a", "31990:1743058db7078661b94aaf4286429d97ee5257d14a86d6bfa54cb0482b876fb0:abcd", <relay-url>, "web" ]
    ]
 }
 ```
 ## User B interacts with a `kind:31337`-handler
 User B might see in their timeline an event referring to a `kind:31337` event
 (e.g. a `kind:1` tagging a `kind:31337`).
 User B's client, not knowing how to handle a `kind:31337` might display the event
 using its `alt` tag (as described in NIP-31). When the user clicks on the event,
 the application queries for a handler for this `kind`:
 `["REQ", <id>, '[{ "kinds": [31989], "#d": ["31337"], 'authors': [<user>, <users-contact-list>] }]']`
 User B, who follows User A, sees that `kind:31989` event and fetches the `a`-tagged event for the app and handler information.
 User B's client sees the application's `kind:31990` which includes the information to redirect the user to the relevant URL with the desired entity replaced in the URL.
 ## Alternative query bypassing `kind:31989`
 Alternatively, users might choose to query directly for `kind:31990` for an event kind. Clients SHOULD be careful doing this and use spam-prevention mechanisms to avoid directing users to malicious handlers.
 `["REQ", <id>, '[{ "kinds": [31990], "#k": [<desired-event-kind>], 'authors': [...] }]']`
--- a/94.md
+++ b/94.md
@ -0,0 +1,51 @@
 NIP-94
 ======
 File Metadata
 -------------
 `draft` `optional` `author:frbitten` `author:kieran` `author:lovvtide` `author:fiatjaf` `author:staab`
 The purpose of this NIP is to allow an organization and classification of shared files. So that relays can filter and organize in any way that is of interest. With that, multiple types of filesharing clients can be created. NIP-94 support is not expected to be implemented by "social" clients that deal with kind:1 notes or by longform clients that deal with kind:30023 articles.
 ## Event format
 This NIP specifies the use of the `1063` event type, having in `content` a description of the file content, and a list of tags described below:
 * `url` the url to download the file
 * `m` a string indicating the data type of the file. The MIME types format must be used (https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/Common_types)
 * `"aes-256-gcm"` (optional)  key and nonce for AES-GCM encryption with tagSize always 128bits
 * `x` containing the SHA-256 hexencoded string of the file.
 * `size` (optional) size of file in bytes
 * `dim` (optional) size of file in pixels in the form `<width>x<height>`
 * `magnet` (optional) URI to magnet file
 * `i` (optional) torrent infohash
 * `blurhash`(optional) the [blurhash](https://github.com/woltapp/blurhash) to show while the file is being loaded by the client
 ```json
 {
  "id": <32-bytes lowercase hex-encoded sha256 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": 1063,
  "tags": [
    ["url",<string with URI of file>],
    ["aes-256-gcm",<key>, <iv>],
    ["m", <MIME type>],
    ["x",<Hash SHA-256>],
    ["size", <size of file in bytes>],
    ["dim", <size of file in pixels>],
    ["magnet",<magnet URI> ],
    ["i",<torrent infohash>],
    ["blurhash", <value>]
  ],
  "content": <description>,
  "sig": <64-bytes hex of the signature of the sha256 hash of the serialized event data, which is the same as the "id" field>
 }
 ```
 ## Suggested use cases
 * A relay for indexing shared files. For example, to promote torrents.
 * A pinterest-like client where people can share their portfolio and inspire others.
 * A simple way to distribute configurations and software updates.
--- a/98.md
+++ b/98.md
@ -0,0 +1,68 @@
 NIP-98
 ======
 HTTP Auth
 -------------------------
 `draft` `optional` `author:kieran` `author:melvincarvalho`
 This NIP defines an ephemerial event used to authorize requests to HTTP servers using nostr events.
 This is useful for HTTP services which are build for Nostr and deal with Nostr user accounts.
 ## Nostr event
 A `kind 27235` (In reference to [RFC 7235](https://www.rfc-editor.org/rfc/rfc7235)) event is used.
 The `content` SHOULD be empty.
 The following tags are defined as REQUIRED.
 * `u` - absolute URL
 * `method` - HTTP Request Method
 Example event:
 ```json
 {
    "id": "fe964e758903360f28d8424d092da8494ed207cba823110be3a57dfe4b578734",
    "pubkey": "63fe6318dc58583cfe16810f86dd09e18bfd76aabc24a0081ce2856f330504ed",
    "content": "",
    "kind": 27235,
    "created_at": 1682327852,
    "tags": [
        [
            "u",
            "https://api.snort.social/api/v1/n5sp/list"
        ],
        [
            "method",
            "GET"
        ]
    ],
    "sig": "5ed9d8ec958bc854f997bdc24ac337d005af372324747efe4a00e24f4c30437ff4dd8308684bed467d9d6be3e5a517bb43b1732cc7d33949a3aaf86705c22184"
 }
 ```
 Servers MUST perform the following checks in order to validate the event:
 1. The `kind` MUST be `27235`.
 2. The `created_at` MUST be within a reasonable time window (suggestion 60 seconds).
 3. The `u` tag MUST be exactly the same as the absolute request URL (including query parameters).
 4. The `method` tag MUST be the same HTTP method used for the requested resource.
 When the request contains a body (as in POST/PUT/PATCH methods) clients SHOULD include a SHA256 hash of the request body in a `payload` tag as hex (`["payload", "<sha256-hex>"]`), servers MAY check this to validate that the requested payload is authorized.
 If one of the checks was to fail the server SHOULD respond with a 401 Unauthorized response code.
 All other checks which server MAY do are OPTIONAL, and implementation specific.
 ## Request Flow
 Using the `Authorization` header, the `kind 27235` event MUST be `base64` encoded and use the Authorization scheme `Nostr`
 Example HTTP Authorization header:
 ```
 Authorization: Nostr eyJpZCI6ImZlOTY0ZTc1ODkwMzM2MGYyOGQ4NDI0ZDA5MmRhODQ5NGVkMjA3Y2JhODIzMTEwYmUzYTU3ZGZlNGI1Nzg3MzQiLCJwdWJrZXkiOiI2M2ZlNjMxOGRjNTg1ODNjZmUxNjgxMGY4NmRkMDllMThiZmQ3NmFhYmMyNGEwMDgxY2UyODU2ZjMzMDUwNGVkIiwiY29udGVudCI6IiIsImtpbmQiOjI3MjM1LCJjcmVhdGVkX2F0IjoxNjgyMzI3ODUyLCJ0YWdzIjpbWyJ1cmwiLCJodHRwczovL2FwaS5zbm9ydC5zb2NpYWwvYXBpL3YxL241c3AvbGlzdCJdLFsibWV0aG9kIiwiR0VUIl1dLCJzaWciOiI1ZWQ5ZDhlYzk1OGJjODU0Zjk5N2JkYzI0YWMzMzdkMDA1YWYzNzIzMjQ3NDdlZmU0YTAwZTI0ZjRjMzA0MzdmZjRkZDgzMDg2ODRiZWQ0NjdkOWQ2YmUzZTVhNTE3YmI0M2IxNzMyY2M3ZDMzOTQ5YTNhYWY4NjcwNWMyMjE4NCJ9
 ```
 ## Reference Implementations
 - C# ASP.NET `AuthenticationHandler` [NostrAuth.cs](https://gist.github.com/v0l/74346ae530896115bfe2504c8cd018d3)
--- a/README.md
+++ b/README.md
@ -1,6 +1,23 @@
 # NIPs
-NIPs stand for **Nostr Implementation Possibilities**. They exist to document what may be implemented by [Nostr](https://github.com/fiatjaf/nostr)-compatible _relay_ and _client_ software.
+NIPs stand for **Nostr Implementation Possibilities**.
 They exist to document what may be implemented by [Nostr](https://github.com/nostr-protocol/nostr)-compatible _relay_ and _client_ software.
 ---
 - [List](#list)
 - [Event Kinds](#event-kinds)
  - [Event Kind Ranges](#event-kind-ranges)
 - [Message Types](#message-types)
  - [Client to Relay](#client-to-relay)
  - [Relay to Client](#relay-to-client)
 - [Standardized Tags](#standardized-tags)
 - [Criteria for acceptance of NIPs](#criteria-for-acceptance-of-nips)
 - [License](#license)
 ---
 ## List
 - [NIP-01: Basic protocol flow description](01.md)
 - [NIP-02: Contact List and Petnames](02.md)
@ -9,15 +26,16 @@ NIPs stand for **Nostr Implementation Possibilities**. They exist to document wh
 - [NIP-05: Mapping Nostr keys to DNS-based internet identifiers](05.md)
 - [NIP-06: Basic key derivation from mnemonic seed phrase](06.md)
 - [NIP-07: `window.nostr` capability for web browsers](07.md)
- [NIP-08: Handling Mentions](08.md)
+- [NIP-08: Handling Mentions](08.md) --- **unrecommended**: deprecated in favor of [NIP-27](27.md)
 - [NIP-09: Event Deletion](09.md)
 - [NIP-10: Conventions for clients' use of `e` and `p` tags in text events](10.md)
 - [NIP-11: Relay Information Document](11.md)
 - [NIP-12: Generic Tag Queries](12.md)
 - [NIP-13: Proof of Work](13.md)
 - [NIP-14: Subject tag in text events.](14.md)
- [NIP-15: End of Stored Events Notice](15.md)
+- [NIP-15: Nostr Marketplace (for resilient marketplaces)](15.md)
 - [NIP-16: Event Treatment](16.md)
 - [NIP-18: Reposts](18.md)
 - [NIP-19: bech32-encoded entities](19.md)
 - [NIP-20: Command Results](20.md)
 - [NIP-21: `nostr:` URL scheme](21.md)
@ -25,88 +43,147 @@ NIPs stand for **Nostr Implementation Possibilities**. They exist to document wh
 - [NIP-23: Long-form Content](23.md)
 - [NIP-25: Reactions](25.md)
 - [NIP-26: Delegated Event Signing](26.md)
 - [NIP-27: Text Note References](27.md)
 - [NIP-28: Public Chat](28.md)
 - [NIP-30: Custom Emoji](30.md)
 - [NIP-31: Dealing with Unknown Events](31.md)
 - [NIP-32: Labeling](32.md)
 - [NIP-33: Parameterized Replaceable Events](33.md)
 - [NIP-36: Sensitive Content](36.md)
 - [NIP-39: External Identities in Profiles](39.md)
 - [NIP-40: Expiration Timestamp](40.md)
 - [NIP-42: Authentication of clients to relays](42.md)
 - [NIP-45: Counting results](45.md)
 - [NIP-46: Nostr Connect](46.md)
 - [NIP-47: Wallet Connect](47.md)
 - [NIP-50: Keywords filter](50.md)
 - [NIP-51: Lists](51.md)
 - [NIP-56: Reporting](56.md)
 - [NIP-57: Lightning Zaps](57.md)
 - [NIP-58: Badges](58.md)
 - [NIP-65: Relay List Metadata](65.md)
 - [NIP-78: Application-specific data](78.md)
 - [NIP-89: Recommended Application Handlers](89.md)
 - [NIP-94: File Metadata](94.md)
 - [NIP-98: HTTP Auth](98.md)
 ## Event Kinds
 | kind    | description                | NIP         |
-| ------------- | -------------------------------- | ----------------------- |
+| ------- | -------------------------- | ----------- |
-| 0             | Metadata                         | [1](01.md), [5](05.md)  |
+| `0`     | Metadata                   | [1](01.md)  |
-| 1             | Short Text Note                  | [1](01.md)              |
+| `1`     | Short Text Note            | [1](01.md)  |
-| 2             | Recommend Relay                  | [1](01.md)              |
+| `2`     | Recommend Relay            | [1](01.md)  |
-| 3             | Contacts                         | [2](02.md)              |
+| `3`     | Contacts                   | [2](02.md)  |
-| 4             | Encrypted Direct Messages        | [4](04.md)              |
+| `4`     | Encrypted Direct Messages  | [4](04.md)  |
-| 5             | Event Deletion                   | [9](09.md)              |
+| `5`     | Event Deletion             | [9](09.md)  |
-| 7             | Reaction                         | [25](25.md)             |
+| `6`     | Repost                     | [18](18.md) |
-| 8             | Badge Award                      | [58](58.md)             |
+| `7`     | Reaction                   | [25](25.md) |
-| 40            | Channel Creation                 | [28](28.md)             |
+| `8`     | Badge Award                | [58](58.md) |
-| 41            | Channel Metadata                 | [28](28.md)             |
+| `16`    | Generic Repost             | [18](18.md) |
-| 42            | Channel Message                  | [28](28.md)             |
+| `40`    | Channel Creation           | [28](28.md) |
-| 43            | Channel Hide Message             | [28](28.md)             |
+| `41`    | Channel Metadata           | [28](28.md) |
-| 44            | Channel Mute User                | [28](28.md)             |
+| `42`    | Channel Message            | [28](28.md) |
-| 45-49         | Public Chat Reserved             | [28](28.md)             |
+| `43`    | Channel Hide Message       | [28](28.md) |
-| 1984          | Reporting                        | [56](56.md)             |
+| `44`    | Channel Mute User          | [28](28.md) |
-| 9734          | Zap Request                      | [57](57.md)             |
+| `1063`  | File Metadata              | [94](94.md) |
-| 9735          | Zap                              | [57](57.md)             |
+| `1984`  | Reporting                  | [56](56.md) |
-| 10002         | Relay List Metadata              | [65](65.md)             |
+| `1985`  | Label                      | [32](32.md) |
-| 22242         | Client Authentication            | [42](42.md)             |
+| `9734`  | Zap Request                | [57](57.md) |
-| 24133         | Nostr Connect                    | [46](46.md)             |
+| `9735`  | Zap                        | [57](57.md) |
-| 30008         | Profile Badges                   | [58](58.md)             |
+| `10000` | Mute List                  | [51](51.md) |
-| 30009         | Badge Definition                 | [58](58.md)             |
+| `10001` | Pin List                   | [51](51.md) |
-| 30023         | Long-form Content                | [23](23.md)             |
+| `10002` | Relay List Metadata        | [65](65.md) |
-| 30078         | Application-specific Data        | [78](78.md)             |
+| `13194` | Wallet Info                | [47](47.md) |
-| 1000-9999     | Regular Events                   | [16](16.md)             |
+| `22242` | Client Authentication      | [42](42.md) |
-| 10000-19999   | Replaceable Events               | [16](16.md)             |
+| `23194` | Wallet Request             | [47](47.md) |
-| 20000-29999   | Ephemeral Events                 | [16](16.md)             |
+| `23195` | Wallet Response            | [47](47.md) |
-| 30000-39999   | Parameterized Replaceable Events | [33](33.md)             |
+| `24133` | Nostr Connect              | [46](46.md) |
 | `27235` | HTTP Auth                  | [98](98.md) |
 | `30000` | Categorized People List    | [51](51.md) |
 | `30001` | Categorized Bookmark List  | [51](51.md) |
 | `30008` | Profile Badges             | [58](58.md) |
 | `30009` | Badge Definition           | [58](58.md) |
 | `30017` | Create or update a stall   | [15](15.md) |
 | `30018` | Create or update a product | [15](15.md) |
 | `30023` | Long-form Content          | [23](23.md) |
 | `30078` | Application-specific Data  | [78](78.md) |
 | `31989` | Handler recommendation     | [89](89.md) |
 | `31990` | Handler information        | [89](89.md) |
 ### Event Kind Ranges
 | range            | description                      | NIP         |
 | ---------------- | -------------------------------- | ----------- |
 | `1000`--`9999`   | Regular Events                   | [16](16.md) |
 | `10000`--`19999` | Replaceable Events               | [16](16.md) |
 | `20000`--`29999` | Ephemeral Events                 | [16](16.md) |
 | `30000`--`39999` | Parameterized Replaceable Events | [33](33.md) |
 ## Message types
 ### Client to Relay
 | type    | description                                         | NIP         |
-|-------|-----------------------------------------------------|-------------|
+| ------- | --------------------------------------------------- | ----------- |
-| EVENT | used to publish events                              | [1](01.md)  |
+| `AUTH`  | used to send authentication events                  | [42](42.md) |
-| REQ   | used to request events and subscribe to new updates | [1](01.md)  |
+| `CLOSE` | used to stop previous subscriptions                 | [1](01.md)  |
-| CLOSE | used to stop previous subscriptions                 | [1](01.md)  |
+| `COUNT` | used to request event counts                        | [45](45.md) |
-| AUTH  | used to send authentication events                  | [42](42.md) |
+| `EVENT` | used to publish events                              | [1](01.md)  |
 | `REQ`   | used to request events and subscribe to new updates | [1](01.md)  |
 ### Relay to Client
 | type     | description                                             | NIP         |
-|--------|---------------------------------------------------------|-------------|
+| -------- | ------------------------------------------------------- | ----------- |
-| EVENT  | used to send events requested to clients                | [1](01.md)  |
+| `AUTH`   | used to send authentication challenges                  | [42](42.md) |
-| NOTICE | used to send human-readable messages to clients         | [1](01.md)  |
+| `COUNT`  | used to send requested event counts to clients          | [45](45.md) |
-| EOSE   | used to notify clients all stored events have been sent | [15](15.md) |
+| `EOSE`   | used to notify clients all stored events have been sent | [1](01.md)  |
-| OK     | used to notify clients if an EVENT was successful       | [20](20.md) |
+| `EVENT`  | used to send events requested to clients                | [1](01.md)  |
-| AUTH   | used to send authentication challenges                  | [42](42.md) |
+| `NOTICE` | used to send human-readable messages to clients         | [1](01.md)  |
 | `OK`     | used to notify clients if an EVENT was successful       | [20](20.md) |
 Please update these lists when proposing NIPs introducing new event kinds.
-When experimenting with kinds, keep in mind the classification introduced by [NIP-16](16.md).
+When experimenting with kinds, keep in mind the classification introduced by [NIP-16](16.md) and [NIP-33](33.md).
 ## Standardized Tags
 | name              | value                                | other parameters     | NIP                      |
-| ---------- | ----------------------- | ----------------- | ------------------------ |
+| ----------------- | ------------------------------------ | -------------------- | ------------------------ |
-| e          | event id (hex)          | relay URL, marker | [1](01.md), [10](10.md)  |
+| `a`               | coordinates to an event              | relay URL            | [33](33.md), [23](23.md) |
-| p          | pubkey (hex)            | relay URL         | [1](01.md)               |
+| `alt`             | Alt tag                              | --                   | [31](31.md)              |
-| a          | coordinates to an event | relay URL         | [33](33.md), [23](23.md) |
+| `d`               | identifier                           | --                   | [33](33.md)              |
-| r          | a reference (URL, etc)  |                   | [12](12.md)              |
+| `e`               | event id (hex)                       | relay URL, marker    | [1](01.md), [10](10.md)  |
-| t          | hashtag                 |                   | [12](12.md)              |
+| `g`               | geohash                              | --                   | [12](12.md)              |
-| g          | geohash                 |                   | [12](12.md)              |
+| `i`               | identity                             | proof                | [39](39.md)              |
-| nonce      | random                  |                   | [13](13.md)              |
+| `l`               | label, label namespace               | annotations          | [32](32.md)              |
-| subject    | subject                 |                   | [14](14.md)              |
+| `L`               | label namespace                      | --                   | [32](32.md)              |
-| d          | identifier              |                   | [33](33.md)              |
+| `p`               | pubkey (hex)                         | relay URL            | [1](01.md)               |
-| expiration | unix timestamp (string) |                   | [40](40.md)              |
+| `r`               | a reference (URL, etc)               | --                   | [12](12.md)              |
 | `t`               | hashtag                              | --                   | [12](12.md)              |
 | `amount`          | millisats                            | --                   | [57](57.md)              |
 | `bolt11`          | `bolt11` invoice                     | --                   | [57](57.md)              |
 | `challenge`       | challenge string                     | --                   | [42](42.md)              |
 | `content-warning` | reason                               | --                   | [36](36.md)              |
 | `delegation`      | pubkey, conditions, delegation token | --                   | [26](26.md)              |
 | `description`     | badge description                    | --                   | [58](58.md)              |
 | `description`     | invoice description                  | --                   | [57](57.md)              |
 | `emoji`           | shortcode                            | image URL            | [30](30.md)              |
 | `expiration`      | unix timestamp (string)              | --                   | [40](40.md)              |
 | `image`           | image URL                            | dimensions in pixels | [23](23.md), [58](58.md) |
 | `lnurl`           | `bech32` encoded `lnurl`             | --                   | [57](57.md)              |
 | `name`            | badge name                           | --                   | [58](58.md)              |
 | `nonce`           | random                               | --                   | [13](13.md)              |
 | `preimage`        | hash of `bolt11` invoice             | --                   | [57](57.md)              |
 | `published_at`    | unix timestamp (string)              | --                   | [23](23.md)              |
 | `relay`           | relay url                            | --                   | [42](42.md)              |
 | `relays`          | relay list                           | --                   | [57](57.md)              |
 | `subject`         | subject                              | --                   | [14](14.md)              |
 | `summary`         | article summary                      | --                   | [23](23.md)              |
 | `thumb`           | badge thumbnail                      | dimensions in pixels | [58](58.md)              |
 | `title`           | article title                        | --                   | [23](23.md)              |
 | `zap`             | profile name                         | type of value        | [57](57.md)              |
 ## Criteria for acceptance of NIPs