nostr 0.3.0 → 0.5.0

data/docs/api-examples.md

@@ -0,0 +1,49 @@
+---
+outline: deep
+---
+
+# Runtime API Examples
+
+This page demonstrates usage of some of the runtime APIs provided by VitePress.
+
+The main `useData()` API can be used to access site, theme, and page data for the current page. It works in both `.md` and `.vue` files:
+
+```md
+<script setup>
+import { useData } from 'vitepress'
+
+const { theme, page, frontmatter } = useData()
+</script>
+
+## Results
+
+### Theme Data
+<pre>{{ theme }}</pre>
+
+### Page Data
+<pre>{{ page }}</pre>
+
+### Page Frontmatter
+<pre>{{ frontmatter }}</pre>
+```
+
+<script setup>
+import { useData } from 'vitepress'
+
+const { site, theme, page, frontmatter } = useData()
+</script>
+
+## Results
+
+### Theme Data
+<pre>{{ theme }}</pre>
+
+### Page Data
+<pre>{{ page }}</pre>
+
+### Page Frontmatter
+<pre>{{ frontmatter }}</pre>
+
+## More
+
+Check out the documentation for the [full list of runtime APIs](https://vitepress.dev/reference/runtime-api#usedata).

data/docs/common-use-cases/bech32-encoding-and-decoding-(NIP-19).md

@@ -0,0 +1,190 @@
+# Encoding/decoding bech-32 strings (NIP-19)
+
+[NIP-19](https://github.com/nostr-protocol/nips/blob/master/19.md) standardizes bech32-formatted strings that can be
+used to display keys, ids and other information in clients. These formats are not meant to be used anywhere in the core
+protocol, they are only meant for displaying to users, copy-pasting, sharing, rendering QR codes and inputting data.
+
+
+In order to guarantee the deterministic nature of the documentation, the examples below assume that there is a `keypair`
+variable with the following values:
+
+```ruby
+keypair = Nostr::KeyPair.new(
+  private_key: Nostr::PrivateKey.new('67dea2ed018072d675f5415ecfaed7d2597555e202d85b3d65ea4e58d2d92ffa'),
+  public_key: Nostr::PublicKey.new('7e7e9c42a91bfef19fa929e5fda1b72e0ebc1a4c1141673e2794234d86addf4e'),
+)
+
+keypair.private_key # => '67dea2ed018072d675f5415ecfaed7d2597555e202d85b3d65ea4e58d2d92ffa'
+keypair.public_key # => '7e7e9c42a91bfef19fa929e5fda1b72e0ebc1a4c1141673e2794234d86addf4e'
+```
+
+## Public key (npub)
+
+### Encoding
+
+```ruby
+npub = Nostr::Bech32.npub_encode('7e7e9c42a91bfef19fa929e5fda1b72e0ebc1a4c1141673e2794234d86addf4e')
+npub # => 'npub10elfcs4fr0l0r8af98jlmgdh9c8tcxjvz9qkw038js35mp4dma8qzvjptg'
+```
+
+### Decoding
+
+```ruby
+type, public_key = Nostr::Bech32.decode('npub10elfcs4fr0l0r8af98jlmgdh9c8tcxjvz9qkw038js35mp4dma8qzvjptg')
+type # => 'npub'
+public_key # => '7e7e9c42a91bfef19fa929e5fda1b72e0ebc1a4c1141673e2794234d86addf4e'
+```
+
+## Private key (nsec)
+
+### Encoding
+
+```ruby
+nsec = Nostr::Bech32.nsec_encode('67dea2ed018072d675f5415ecfaed7d2597555e202d85b3d65ea4e58d2d92ffa')
+nsec # => 'nsec1vl029mgpspedva04g90vltkh6fvh240zqtv9k0t9af8935ke9laqsnlfe5'
+```
+
+### Decoding
+
+```ruby
+type, private_key = Nostr::Bech32.decode('nsec1vl029mgpspedva04g90vltkh6fvh240zqtv9k0t9af8935ke9laqsnlfe5')
+type # => 'npub'
+private_key # => '67dea2ed018072d675f5415ecfaed7d2597555e202d85b3d65ea4e58d2d92ffa'
+```
+
+## Relay (nrelay)
+
+### Encoding
+
+```ruby
+nrelay = Nostr::Bech32.nrelay_encode('wss://relay.damus.io')
+nrelay # => 'nrelay1qq28wumn8ghj7un9d3shjtnyv9kh2uewd9hsc5zt2x'
+```
+
+### Decoding
+
+```ruby
+type, data = Nostr::Bech32.decode('nrelay1qq28wumn8ghj7un9d3shjtnyv9kh2uewd9hsc5zt2x')
+
+type # => 'nrelay'
+data.entries.first.label # => 'relay'
+data.entries.first.value # => 'wss://relay.damus.io'
+```
+
+## Event (nevent)
+
+### Encoding
+
+```ruby{8-12}
+user = Nostr::User.new(keypair: keypair)
+text_note_event = user.create_event(
+  kind: Nostr::EventKind::TEXT_NOTE,
+  created_at: 1700467997,
+  content: 'Your feedback is appreciated, now pay $8'
+)
+
+nevent = Nostr::Bech32.nevent_encode(
+  id: text_note_event.id,
+  relays: ['wss://relay.damus.io', 'wss://nos.lol'],
+  kind: Nostr::EventKind::TEXT_NOTE,
+)
+
+nevent # => 'nevent1qgsqlkuslr3rf56qpmd0m5ndfyl39m7q6l0zcmuly8ue0praxwkjagcpz3mhxue69uhhyetvv9ujuerpd46hxtnfduqs6amnwvaz7tmwdaejumr0dspsgqqqqqqs03k8v3'
+```
+
+### Decoding
+
+```ruby
+type, event = Nostr::Bech32.decode('nevent1qgsqlkuslr3rf56qpmd0m5ndfyl39m7q6l0zcmuly8ue0praxwkjagcpz3mhxue69uhhyetvv9ujuerpd46hxtnfduqs6amnwvaz7tmwdaejumr0dspsgqqqqqqs03k8v3')
+
+type # => 'nevent'
+event.entries[0].label # => 'author'
+event.entries[0].value # => '7e7e9c42a91bfef19fa929e5fda1b72e0ebc1a4c1141673e2794234d86addf4e'
+event.entries[1].relay # => 'relay'
+event.entries[1].value # => 'wss://relay.damus.io'
+event.entries[2].label # => 'relay'
+event.entries[2].value # => 'wss://nos.lol'
+event.entries[3].label # => 'kind'
+event.entries[3].value # => 1
+```
+
+## Address (naddr)
+
+### Encoding
+
+```ruby
+naddr = Nostr::Bech32.naddr_encode(
+  pubkey: keypair.public_key,
+  relays: ['wss://relay.damus.io', 'wss://nos.lol'],
+  kind: Nostr::EventKind::TEXT_NOTE,
+  identifier: 'damus',
+)
+
+naddr # => 'naddr1qgs8ul5ug253hlh3n75jne0a5xmjur4urfxpzst88cnegg6ds6ka7nspz3mhxue69uhhyetvv9ujuerpd46hxtnfduqs6amnwvaz7tmwdaejumr0dspsgqqqqqqsqptyv9kh2uc3qfs2p'
+```
+
+### Decoding
+
+```ruby
+type, addr = Nostr::Bech32.decode('naddr1qgs8ul5ug253hlh3n75jne0a5xmjur4urfxpzst88cnegg6ds6ka7nspz3mhxue69uhhyetvv9ujuerpd46hxtnfduqs6amnwvaz7tmwdaejumr0dspsgqqqqqqsqptyv9kh2uc3qfs2p')
+
+type # => 'naddr'
+addr.entries[0].label # => 'author'
+addr.entries[0].value # => '7e7e9c42a91bfef19fa929e5fda1b72e0ebc1a4c1141673e2794234d86addf4e'
+addr.entries[1].label # => 'relay'
+addr.entries[1].value # => 'wss://relay.damus.io'
+addr.entries[2].label # => 'relay'
+addr.entries[2].value # => 'wss://nos.lol'
+addr.entries[3].label # => 'kind'
+addr.entries[3].value # => 1
+addr.entries[4].label # => 'identifier'
+addr.entries[4].value # => 'damus'
+```
+
+## Profile (nprofile)
+
+### Encoding
+```ruby
+relay_urls = %w[wss://relay.damus.io wss://nos.lol]
+nprofile = Nostr::Bech32.nprofile_encode(pubkey: keypair.public_key, relays: relay_urls)
+
+nprofile # => nprofile1qqs8ul5ug253hlh3n75jne0a5xmjur4urfxpzst88cnegg6ds6ka7nspz3mhxue69uhhyetvv9ujuerpd46hxtnfduqs6amnwvaz7tmwdaejumr0dsxe58m5
+```
+
+### Decoding
+
+```ruby
+type, profile = Nostr::Bech32.decode('nprofile1qqs8ul5ug253hlh3n75jne0a5xmjur4urfxpzst88cnegg6ds6ka7nspz3mhxue69uhhyetvv9ujuerpd46hxtnfduqs6amnwvaz7tmwdaejumr0dsxe58m5')
+
+type # => 'nprofile'
+profile.entries[0].label # => 'pubkey'
+profile.entries[0].value # => '7e7e9c42a91bfef19fa929e5fda1b72e0ebc1a4c1141673e2794234d86addf4e'
+profile.entries[1].label # => 'relay'
+profile.entries[1].value # => 'wss://relay.damus.io'
+profile.entries[2].label # => 'relay'
+profile.entries[2].value # => 'wss://nos.lol'
+```
+
+## Other simple types (note)
+
+### Encoding
+
+```ruby{8-9}
+user = Nostr::User.new(keypair: keypair)
+text_note_event = user.create_event(
+  kind: Nostr::EventKind::TEXT_NOTE,
+  created_at: 1700467997,
+  content: 'Your feedback is appreciated, now pay $8'
+)
+
+note = Nostr::Bech32.encode(hrp: 'note', data: text_note_event.id)
+note # => 'note10elfcs4fr0l0r8af98jlmgdh9c8tcxjvz9qkw038js35mp4dma8qnx3ujq'
+```
+
+### Decoding
+
+```ruby
+type, note = Nostr::Bech32.decode('note1pldep78zxnf5qrk6lhfx6jflzthup47793he7g0ej7z86vad963s42v0rr')
+type # => 'note'
+note # => '0fdb90f8e234d3400edafdd26d493f12efc0d7de2c6f9f21f997847d33ad2ea3'
+```

data/docs/core/client.md

@@ -0,0 +1,108 @@
+# Client
+
+Clients establish a WebSocket connection to [relays](../relays/connecting-to-a-relay). Through this connection, clients
+communicate and subscribe to a range of [Nostr events](../events) based on specified subscription filters. These filters
+define the Nostr events a client wishes to receive updates about.
+
+::: info
+Clients do not need to sign up or create an account to use Nostr. Upon connecting to a relay, a client provides
+its subscription filters. The relay then streams events that match these filters to the client for the duration of the
+connection.
+:::
+
+## WebSocket events
+
+Communication between clients and relays happen via WebSockets. The client will emit WebSocket events when the
+connection is __opened__, __closed__, when a __message__ is received or when there's an __error__.
+
+::: info
+WebSocket events are not [Nostr events](https://nostr.com/the-protocol/events). They are events emitted by the
+WebSocket connection. The WebSocket `:message` event, however, contains a Nostr event in its payload.
+:::
+
+### connect
+
+The `:connect` event is fired when a connection with a WebSocket is opened. You must call `Nostr::Client#connect` first.
+
+```ruby
+client = Nostr::Client.new
+relay = Nostr::Relay.new(url: 'wss://relay.damus.io', name: 'Damus')
+
+client.on :connect do
+  # When this block executes, you're connected to the relay
+end
+
+# Connect to a relay asynchronously
+client.connect(relay)
+```
+
+Once the connection is open, you can send events to the relay, manage subscriptions, etc.
+
+::: tip
+Define the connection event handler before calling
+[`Nostr::Client#connect`](https://www.rubydoc.info/gems/nostr/Nostr/Client#connect-instance_method). Otherwise,
+you may miss the event.
+:::
+
+### error
+
+The `:error` event is fired when a connection with a WebSocket has been closed because of an error.
+
+```ruby
+client.on :error do |error_message|
+  puts error_message
+end
+
+# > Network error: wss://rsslay.fiatjaf.com: Unable to verify the
+# server certificate for 'rsslay.fiatjaf.com'
+```
+
+### message
+
+The `:message` event is fired when data is received through a WebSocket.
+
+```ruby
+client.on :message do |message|
+  puts message
+end
+```
+
+The message will be one of these 4 types, which must also be JSON arrays, according to the following patterns:
+- `["EVENT", <subscription_id>, <event JSON>]`
+- `["OK", <event_id>, <true|false>, <message>]`
+- `["EOSE", <subscription_id>]`
+- `["NOTICE", <message>]`
+
+::: details Click me to see how a WebSocket message looks like
+```ruby
+[
+  "EVENT",
+  "d34107357089bfc9882146d3bfab0386",
+  {
+    "content": "",
+    "created_at": 1676456512,
+    "id": "18f63550da74454c5df7caa2a349edc5b2a6175ea4c5367fa4b4212781e5b310",
+    "kind": 3,
+    "pubkey": "117a121fa41dc2caa0b3d6c5b9f42f90d114f1301d39f9ee96b646ebfee75e36",
+    "sig": "d171420bd62cf981e8f86f2dd8f8f86737ea2bbe2d98da88db092991d125535860d982139a3c4be39886188613a9912ef380be017686a0a8b74231dc6e0b03cb",
+    "tags":[
+      ["p", "1cc821cc2d47191b15fcfc0f73afed39a86ac6fb34fbfa7993ee3e0f0186ef7c"]
+    ]
+  }
+]
+```
+:::
+
+### close
+
+The `:close` event is fired when a connection with a WebSocket is closed.
+
+```ruby
+client.on :close do |code, reason|
+  puts "Error: #{code} - #{reason}"
+end
+```
+
+::: tip
+This handler is useful to attempt to reconnect to the relay.
+:::

data/docs/core/keys.md

@@ -0,0 +1,136 @@
+# Keys
+
+To [sign events](#signing-an-event), you need a **private key**. To verify signatures, you need a **public key**. The combination of a
+private and a public key is called a **keypair**.
+
+Both public and private keys are 64-character hexadecimal strings. They can be represented in bech32 format,
+which is a human-readable format that starts with `nsec` for private keys and `npub` for public keys.
+
+There are a few ways to generate a keypair.
+
+## a) Generating a keypair
+
+If you don't have any keys, you can generate a keypair using the
+[`Nostr::Keygen`](https://www.rubydoc.info/gems/nostr/Nostr/Keygen) class:
+
+```ruby
+keygen  = Nostr::Keygen.new
+keypair = keygen.generate_key_pair
+
+keypair.private_key # => '67dea2ed018072d675f5415ecfaed7d2597555e202d85b3d65ea4e58d2d92ffa'
+keypair.public_key # => '7e7e9c42a91bfef19fa929e5fda1b72e0ebc1a4c1141673e2794234d86addf4e'
+```
+
+## b) Generating a private key and a public key
+
+Alternatively, if you have already generated a private key, you can extract the corresponding public key by calling
+`Keygen#extract_public_key`:
+
+```ruby
+keygen  = Nostr::Keygen.new
+
+private_key = keygen.generate_private_key
+public_key  = keygen.extract_public_key(private_key)
+
+private_key # => '67dea2ed018072d675f5415ecfaed7d2597555e202d85b3d65ea4e58d2d92ffa'
+public_key # => '7e7e9c42a91bfef19fa929e5fda1b72e0ebc1a4c1141673e2794234d86addf4e'
+```
+
+## c) Using existing hexadecimal keys
+
+If you already have a private key and a public key in hexadecimal format, you can create a keypair using the
+`Nostr::KeyPair` class:
+
+```ruby
+keypair = Nostr::KeyPair.new(
+  private_key: Nostr::PrivateKey.new('67dea2ed018072d675f5415ecfaed7d2597555e202d85b3d65ea4e58d2d92ffa'),
+  public_key: Nostr::PublicKey.new('7e7e9c42a91bfef19fa929e5fda1b72e0ebc1a4c1141673e2794234d86addf4e'),
+)
+
+keypair.private_key # => '67dea2ed018072d675f5415ecfaed7d2597555e202d85b3d65ea4e58d2d92ffa'
+keypair.public_key # => '7e7e9c42a91bfef19fa929e5fda1b72e0ebc1a4c1141673e2794234d86addf4e'
+```
+
+### d) Use existing bech32 keys
+
+If you already have a private key and a public key in bech32 format, you can create a keypair using the
+`Nostr::KeyPair` class:
+
+```ruby
+keypair = Nostr::KeyPair.new(
+  private_key: Nostr::PrivateKey.from_bech32('nsec1vl029mgpspedva04g90vltkh6fvh240zqtv9k0t9af8935ke9laqsnlfe5'),
+  public_key: Nostr::PublicKey.from_bech32('npub10elfcs4fr0l0r8af98jlmgdh9c8tcxjvz9qkw038js35mp4dma8qzvjptg'),
+)
+
+keypair.private_key # => '67dea2ed018072d675f5415ecfaed7d2597555e202d85b3d65ea4e58d2d92ffa'
+keypair.public_key # => '7e7e9c42a91bfef19fa929e5fda1b72e0ebc1a4c1141673e2794234d86addf4e'
+```
+
+## e) Using an existing hexadecimal private key
+
+If you already have a private key in hexadecimal format, you can create a keypair using the method
+[`Nostr::Keygen#get_key_pair_from_private_key`](https://www.rubydoc.info/gems/nostr/Nostr/Keygen#get_key_pair_from_private_key-instance_method):
+
+```ruby
+private_key = Nostr::PrivateKey.new('67dea2ed018072d675f5415ecfaed7d2597555e202d85b3d65ea4e58d2d92ffa')
+
+keygen= Nostr::Keygen.new
+keypair = keygen.get_key_pair_from_private_key(private_key)
+
+keypair.private_key # => '67dea2ed018072d675f5415ecfaed7d2597555e202d85b3d65ea4e58d2d92ffa'
+keypair.public_key # => '7e7e9c42a91bfef19fa929e5fda1b72e0ebc1a4c1141673e2794234d86addf4e'
+```
+
+## f) Using an existing bech32 private key
+
+If you already have a private key in bech32 format, you can create a keypair using the methods
+[`Nostr::PrivateKey.from_bech32`](https://www.rubydoc.info/gems/nostr/Nostr/PrivateKey.from_bech32-class_method) and
+[`Nostr::Keygen#get_key_pair_from_private_key`](https://www.rubydoc.info/gems/nostr/Nostr/Keygen#get_key_pair_from_private_key-instance_method):
+
+```ruby
+private_key = Nostr::PrivateKey.from_bech32('nsec1vl029mgpspedva04g90vltkh6fvh240zqtv9k0t9af8935ke9laqsnlfe5')
+
+keygen= Nostr::Keygen.new
+keypair = keygen.get_key_pair_from_private_key(private_key)
+
+keypair.private_key # => '67dea2ed018072d675f5415ecfaed7d2597555e202d85b3d65ea4e58d2d92ffa'
+keypair.public_key # => '7e7e9c42a91bfef19fa929e5fda1b72e0ebc1a4c1141673e2794234d86addf4e'
+```
+
+## Signing an event
+
+KeyPairs are used to sign [events](../events). To create a signed event, you need to instantiate a
+[`Nostr::User`](https://www.rubydoc.info/gems/nostr/Nostr/User) with a keypair:
+
+```ruby{8,11-14}
+# Use an existing keypair
+keypair = Nostr::KeyPair.new(
+  private_key: Nostr::PrivateKey.new('67dea2ed018072d675f5415ecfaed7d2597555e202d85b3d65ea4e58d2d92ffa'),
+  public_key: Nostr::PublicKey.new('7e7e9c42a91bfef19fa929e5fda1b72e0ebc1a4c1141673e2794234d86addf4e'),
+)
+
+# Add the keypair to a user
+user = Nostr::User.new(keypair: keypair)
+
+# Create signed events
+text_note = user.create_event(
+  kind: Nostr::EventKind::TEXT_NOTE,
+  content: 'Your feedback is appreciated, now pay $8'
+)
+```
+
+::: details Click me to view the text_note
+
+```ruby
+# text_note.to_h
+{
+  id: '030fbc71151379e5b58e7428ed6e7f2884e5dfc9087fd64d1dc4cc677f5097c8',
+  pubkey: '7e7e9c42a91bfef19fa929e5fda1b72e0ebc1a4c1141673e2794234d86addf4e', # from the keypair
+  created_at: 1700119819,
+  kind: 1, # Nostr::EventKind::TEXT_NOTE,
+  tags: [],
+  content: 'Your feedback is appreciated, now pay $8',
+  sig: '586877896ef6f7d54fa4dd2ade04e3fdc4dfcd6166dd0df696b3c3c768868c0b690338f5baed6ab4fc717785333cb487363384de9fb0f740ac4775522cb4acb3' # signed with the private key from the keypair
+}
+```
+:::

data/docs/core/user.md

@@ -0,0 +1,43 @@
+# User
+
+The class [`Nostr::User`](https://www.rubydoc.info/gems/nostr/Nostr/User) is an abstraction to facilitate the creation
+of signed events. It is not required to use it to create events, but it is recommended.
+
+Here's an example of how to create a signed event without the class `Nostr::User`:
+
+```ruby
+event = Nostr::Event.new(
+  pubkey: keypair.public_key,
+  kind: Nostr::EventKind::TEXT_NOTE,
+  tags: [],
+  content: 'Your feedback is appreciated, now pay $8',
+)
+event.sign(keypair.private_key)
+```
+
+::: details Click me to view the event
+
+```ruby
+# event.to_h
+{
+  id: '5feb10973dbcf5f210cfc1f0aa338fee62bed6a29696a67957713599b9baf0eb',
+  pubkey: 'b9b9821074d1b60b8fb4a3983632af3ef9669f55b20d515bf982cda5c439ad61',
+  created_at: 1699847447,
+  kind: 1, # Nostr::EventKind::TEXT_NOTE,
+  tags: [],
+  content: 'Your feedback is appreciated, now pay $8',
+  sig: 'e30f2f08331f224e41a4099d16aefc780bf9f2d1191b71777e1e1789e6b51fdf7bb956f25d4ea9a152d1c66717a9d68c081ce6c89c298c3c5e794914013381ab'
+}
+```
+:::
+
+And here's how to create it with the class `Nostr::User`:
+
+```ruby
+user = Nostr::User.new(keypair: keypair)
+
+event = user.create_event(
+  kind: Nostr::EventKind::TEXT_NOTE,
+  content: 'Your feedback is appreciated, now pay $8'
+)
+```

data/docs/events/contact-list.md

@@ -0,0 +1,29 @@
+# Contact List
+
+## Creating/updating your contact list
+
+Every new contact list that gets published overwrites the past ones, so it should contain all entries.
+
+```ruby
+# Creating a contact list event with 2 contacts
+update_contacts_event = user.create_event(
+  kind: Nostr::EventKind::CONTACT_LIST,
+  tags: [
+    [
+      "p", # mandatory
+      "32e1827635450ebb3c5a7d12c1f8e7b2b514439ac10a67eef3d9fd9c5c68e245", # public key of the user to add to the contacts
+      "wss://alicerelay.com/", # can be an empty string or can be omitted
+      "alice" # can be an empty string or can be omitted
+    ],
+    [
+      "p", # mandatory
+      "3efdaebb1d8923ebd99c9e7ace3b4194ab45512e2be79c1b7d68d9243e0d2681", # public key of the user to add to the contacts
+      "wss://bobrelay.com/nostr", # can be an empty string or can be omitted
+      "bob" # can be an empty string or can be omitted
+    ],
+  ],
+)
+
+# Send it to the Relay
+client.publish(update_contacts_event)
+```

data/docs/events/encrypted-direct-message.md

@@ -0,0 +1,28 @@
+# Encrypted Direct Message
+
+## Sending an encrypted direct message
+
+```ruby
+sender_private_key = '3185a47e3802f956ca5a2b4ea606c1d51c7610f239617e8f0f218d55bdf2b757'
+
+encrypted_direct_message = Nostr::Events::EncryptedDirectMessage.new(
+   sender_private_key: sender_private_key,
+   recipient_public_key: '6c31422248998e300a1a457167565da7d15d0da96651296ee2791c29c11b6aa0',
+   plain_text: 'Your feedback is appreciated, now pay $8',
+   previous_direct_message: 'ccf9fdf3e1466d7c20969c71ec98defcf5f54aee088513e1b73ccb7bd770d460' # optional
+)
+
+encrypted_direct_message.sign(sender_private_key)
+
+# #<Nostr::Events::EncryptedDirectMessage:0x0000000104c9fa68
+# @content="mjIFNo1sSP3KROE6QqhWnPSGAZRCuK7Np9X+88HSVSwwtFyiZ35msmEVoFgRpKx4?iv=YckChfS2oWCGpMt1uQ4GbQ==",
+#   @created_at=1676456512,
+#   @id="daac98826d5eb29f7c013b6160986c4baf4fe6d4b995df67c1b480fab1839a9b",
+#   @kind=4,
+#   @pubkey="8a9d69c56e3c691bec8f9565e4dcbe38ae1d88fffeec3ce66b9f47558a3aa8ca",
+#   @sig="028bb5f5bab0396e2065000c84a4bcce99e68b1a79bb1b91a84311546f49c5b67570b48d4a328a1827e7a8419d74451347d4f55011a196e71edab31aa3d6bdac",
+#   @tags=[["p", "6c31422248998e300a1a457167565da7d15d0da96651296ee2791c29c11b6aa0"], ["e", "ccf9fdf3e1466d7c20969c71ec98defcf5f54aee088513e1b73ccb7bd770d460"]]>
+
+# Send it to the Relay
+client.publish(encrypted_direct_message)
+```

data/docs/events/recommend-server.md

@@ -0,0 +1,32 @@
+# Recommend Server
+
+The `Recommend Server` event, has a set of tags with the following structure `['e', <event-id>, <relay-url>, <marker>]`
+
+Where:
+
+- `<event-id>` is the id of the event being referenced.
+- `<relay-url>` is the URL of a recommended relay associated with the reference. Clients SHOULD add a valid `<relay-URL>`
+field, but may instead leave it as `''`.
+- `<marker>` is optional and if present is one of `'reply'`, `'root'`, or `'mention'`.
+Those marked with `'reply'` denote the id of the reply event being responded to. Those marked with `'root'` denote the
+root id of the reply thread being responded to. For top level replies (those replying directly to the root event),
+only the `'root'` marker should be used. Those marked with `'mention'` denote a quoted or reposted event id.
+
+A direct reply to the root of a thread should have a single marked `'e'` tag of type `'root'`.
+
+## Recommending a server
+
+```ruby
+recommend_server_event = user.create_event(
+  kind: Nostr::EventKind::RECOMMEND_SERVER,
+  tags: [
+    [
+      'e',
+      '461544014d87c9eaf3e76e021240007dff2c7afb356319f99c741b45749bf82f',
+      'wss://relay.damus.io'
+    ],
+  ]
+)
+
+client.publish(recommend_server_event)
+```

data/docs/events/set-metadata.md

@@ -0,0 +1,20 @@
+# Set Metadata
+
+In the `Metadata` event, the `content` is set to a stringified JSON object
+`{name: <username>, about: <string>, picture: <url, string>}` describing the [user](../core/user) who created the event. A relay may
+delete older events once it gets a new one for the same pubkey.
+
+## Setting the user's metadata
+
+```ruby
+metadata_event = user.create_event(
+  kind: Nostr::EventKind::SET_METADATA,
+  content: {
+    name: 'Wilson Silva',
+    about: 'Used to make hydrochloric acid bombs in high school.',
+    picture: 'https://thispersondoesnotexist.com/'
+  }
+)
+
+client.publish(metadata_event)
+```

data/docs/events/text-note.md

@@ -0,0 +1,15 @@
+# Text Note
+
+In the `Text Note` event, 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.
+
+## Sending a text note event
+
+```ruby
+text_note_event = user.create_event(
+  kind: Nostr::EventKind::TEXT_NOTE,
+  content: 'Your feedback is appreciated, now pay $8'
+)
+
+client.publish(text_note_event)
+```

data/docs/events.md

@@ -0,0 +1,11 @@
+# Events
+
+## Event Kinds
+
+| kind          | description                                                    | NIP                                                            |
+| ------------- |----------------------------------------------------------------| -------------------------------------------------------------- |
+| `0`           | [Metadata](./events/set-metadata)                              | [1](https://github.com/nostr-protocol/nips/blob/master/01.md)  |
+| `1`           | [Short Text Note](./events/text-note)                          | [1](https://github.com/nostr-protocol/nips/blob/master/01.md)  |
+| `2`           | [Recommend Relay](./events/recommend-server)                   |                                                                |
+| `3`           | [Contacts](./events/contact-list)                              | [2](https://github.com/nostr-protocol/nips/blob/master/02.md)  |
+| `4`           | [Encrypted Direct Messages](./events/encrypted-direct-message) | [4](https://github.com/nostr-protocol/nips/blob/master/04.md)  |