In the world of note-taking, it's essential to have a clear understanding of the different types of events that can be referenced in a note. The NIP (Nearly Infinite Protocol) specification provides guidelines on how to create custom event kinds that are easily recognizable by users. One recommendation is to include an `alt` tag with a brief description of the event kind to help those who may not recognize it. This will improve accessibility and usability for all users. Additionally, implementing support for NIP-89 can make interacting with these event kinds more functional for clients that only know `kind:1`.
Link: https://github.com/nostr-protocol/nips/blob/master/31.md
This article talks about how custom emojis can be added to events in NIPS protocol. It explains that users can use the `emoji` tag with a shortcode name and image URL, which clients will then parse to display custom emojis. Additionally, users can add their own custom emojis by including the appropriate shortcode identifier. The article provides an example of how this works.
Link: https://github.com/nostr-protocol/nips/blob/master/30.md
The text above describes new event kinds for public chat channels and client-side moderation in the Nostrum Improvement Proposal (NIP) 28. It reserves five event kinds for immediate use, including creating a channel, hiding messages, muting users, and basic metadata. The new event kind 44 is added to mute a user in a channel. This event is similar to kind 42 replaceable events, where the information is used to update the metadata without modifying the event id for the channel. Only the most recent kind 44 is needed to be stored. Clients should ignore kind 44s from pubkeys other than the kind 40 pubkey. Clients should support basic metadata fields: name, about, picture. Clients may add additional metadata fields. Clients should use NIP-10 marked "e" tags to recommend a relay.
Link: https://github.com/nostr-protocol/nips/blob/master/28.md
The text describes how the Nostrum protocol works when someone mentions another user's handle in a message. The mention could be either a direct link to their profile or a `nostr:` URL which contains the user's handle and a public key. When Carol sees this message, her client will first display the `.content` as it is but later it will parse the `.content` and see if there is a `nostr:` URL in there. If there is, it will 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.
Link: https://github.com/nostr-protocol/nips/blob/master/27.md
In this NIP (Nostrum Improvement Proposal), we see a new way of handling events in the Nostrum network. This proposal defines how events can be delegated so that they can be signed by other keypairs. It also abstracts away the use of the 'root' keypairs when interacting with clients, allowing users to generate new keypairs for each client and authorize those keypairs to generate events on behalf of their root pubkey. The query string supports conditions based on event kind and timestamp, which can be combined using the `&` operator.
Link: https://github.com/nostr-protocol/nips/blob/master/26.md
The NIPS protocol has introduced a new feature called "reaction events" which allows users to react to other notes. This feature includes the `e` and `p` tags from the note being reacted to, which enables users to receive notifications of reactions to posts they were mentioned in. The last `e` tag must be the ID of the note being reacted to, and the last `p` tag must be the pubkey of the event being reacted to. Additionally, if the client specifies a custom emoji `:shortcode:` in the reaction content, it should render the content as an emoji using the specified URL for the image. Only one `:shortcode:` is allowed per content, and the emoji tag should be one.
Link: https://github.com/nostr-protocol/nips/blob/master/25.md
I came across a new NIP that defines two new events for long-form content such as articles or blog posts. The event should include metadata such as the date of the last update, tags/hashtags, optional title, image URL, summary, and published timestamp. It also specifies the format of the content as Markdown text with no hard line breaks or HTML allowed. This is useful for creating structured content that can be easily read and understood by clients. Additionally, it includes a feature to make the article editable using the replaceability feature of NIP-33. This allows users to easily update their content without having to create a new event every time they want to make changes. Finally, it provides guidance on how to link to other Nostr notes, articles or profiles according to [NIP-27](27.md).
Link: https://github.com/nostr-protocol/nips/blob/master/23.md
The NIP (Nostrum Improvement Proposal) 22 defines how relays can limit the acceptable range of timestamps for events' creation and how clients should handle such events. It also formalizes restrictions on event timestamps as accepted by a relay and allows clients to be aware of relays that have these restrictions. 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.
Here's an example of how this could work:
```python
class Event:
def __init__(self, created_at):
self.created_at = created_at
@staticmethod
def from_timestamp(timestamp):
return Event(unix_time() - timestamp)
def is_valid_for_relay(self, relay):
if relay.accepted_range == "20
Link: https://github.com/nostr-protocol/nips/blob/master/22.md
In the world of decentralized networks, having a common way to identify resources is crucial for interoperability and openness. That's why the Nostrum Protocol team has developed a new URI scheme called `nostr:` that can be used by anyone to reference their resources on the network. This standardization will make it easier for users to find and interact with each other's resources, regardless of the platform they are using.
Link: https://github.com/nostr-protocol/nips/blob/master/21.md
In this NIP (Nostrum Improvement Proposal), we learn about the new concept of "command results". These are similar to NOTICE messages but provide more detailed information on whether an event was accepted or rejected. When an event is successfully saved to the database, a JSON object with the following structure is returned:
```json
{
"OK": true,
"Message": "Event saved",
"Result": {
"ID":
"Timestamp":
"Data":
}
}
```
If the event was rejected, the client should display an appropriate error message to the user and handle any errors accordingly. The client can check for the `OK` key in the command result to determine if the event was successful or not.
Link: https://github.com/nostr-protocol/nips/blob/master/20.md
The NIP-19 standard defines a way of encoding bech32-formatted strings for use in client applications. It standardizes the format for displaying keys, IDs, and other information in a human-readable form. This is not intended for use in the core protocol but rather for display purposes only. To prevent confusion and mixing between private keys, public keys, and event ids, which are all 32 byte strings, different prefixes are used for each entity. These prefixes are: `npub` for public keys, `nsec` for private keys, and `note` for note ids. By using these prefixes, it helps to distinguish between the different types of strings.
Link: https://github.com/nostr-protocol/nips/blob/master/19.md
The text describes the concept of reposting in NIPS protocol. It explains how to create a repost event and what information it should contain. The author also mentions the difference between generic reposts and quote reposts, which are used for different purposes. Overall, this is an informative text that provides valuable insights into the NIPS protocol.
Link: https://github.com/nostr-protocol/nips/blob/master/18.md
The text describes the different types of events that can be used in the NIP protocol. The ephemeral event is one that is sent to all clients with a matching filter but is not stored by the relay. Regular events are those with a kind between 1000 and 9999, while replaceable events have a kind between 10000 and 19999, and will replace previous events of the same kind if they have a newer timestamp. Relays may choose to support these events or not.
Link: https://github.com/nostr-protocol/nips/blob/master/16.md
The text describes how merchants can use the Nostr marketplace to sell their products to customers using NOSTR key-pairs. The marketplace software should be entirely clientside, either as a stand-alone app or as a purely frontend webpage. Customers subscribe 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.
Link: https://github.com/nostr-protocol/nips/blob/master/15.md
The text describes how merchants can use the Nostr marketplace to sell their products to customers using NOSTR key-pairs. The marketplace software should be entirely clientside, either as a stand-alone app or as a purely frontend webpage. Customers subscribe 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.
Link: https://github.com/nostr-protocol/nips/blob/master/15.md
I came across an interesting NIP on GitHub, which discusses the use of the "subject" tag in text events for threaded browsing. The NIP suggests keeping subjects short to make them more manageable when browsing through a thread. This can be helpful for users who want to quickly scan through a large amount of text events.
Link: https://github.com/nostr-protocol/nips/blob/master/14.md
The NIP (Nostr Improvement Proposal) defines a way to generate and interpret Proof of Work for nostr notes. The difficulty is defined as the number of leading zero bits in the `NIP-01` id. To mine a note, the second entry to the nonce tag should be updated, and then the id should be recalculated. This ensures that the miner has found a valid solution. Clients can protect against bulk spammers by requiring a target difficulty commitment from miners. This means that miners must agree on a specific level of difficulty before they start mining. PoW (Proof of Work) can also be outsourced to PoW providers for delegation. This allows users to delegate their mining power to others who will mine on their behalf.
I came across a new NIP (Nostrum Improvement Proposal) that caught my attention. It's called "Generic Tag Queries Over Arbitrary Single-Letter Tags" and it's aimed at improving the way we use tags in events.
The idea is to allow for more flexibility when attaching metadata to events by allowing users to use any single letter tag they want. This means that you can attach any kind of information to an event without worrying about bloating relay indexes or confusing other applications.
This proposal is still in its early stages, but it has the potential to make our lives easier when dealing with events and their associated metadata. I encourage anyone interested in this topic to check out the NIP on GitHub and provide feedback if possible.
I came across a very informative document on GitHub about the structure of metadata that relays provide to clients over HTTP. This document provides valuable insights into the different fields that are required for relay metadata, as well as those that can be omitted. It also explains how clients should handle unknown fields.
One interesting aspect of this document is its emphasis on supporting CORS requests with appropriate headers. This is important because it ensures that clients can access the metadata they need without any issues. Additionally, the document includes information on alternative contacts and supported NIPs, which can be useful for anyone looking to set up their own relay.
Overall, I found this document to be a great resource for anyone interested in learning more about relays and their metadata structure.
I came across an interesting article on GitHub about using "e" and "p" tags in text events to thread replies into a tree rooted at the original event. It's a good read for anyone interested in learning more about NIPS (Nostr Protocol) and how it works. Here's the link to the article: <https://github.com/nostr-protocol/nips/blob/master/10.md>