refactor: rustfmt

Prior to this, the NIP05 verifier would receieve metadata events for
GRPC-denied events.  If  the verifier passed, it would try to write
the verification record, but referencing a non-existent event, which
would fail with a SQL constraint error.

.build.yml

@@ -0,0 +1,20 @@
+image: fedora/latest
+arch: x86_64
+artifacts:
+  - nostr-rs-relay/target/release/nostr-rs-relay
+environment:
+  RUST_LOG: debug
+packages:
+  - cargo
+  - sqlite-devel
+  - protobuf-compiler
+sources:
+  - https://git.sr.ht/~gheartsfield/nostr-rs-relay/
+shell: false
+tasks:
+  - build: |
+      cd nostr-rs-relay
+      cargo build --release
+  - test: |
+      cd nostr-rs-relay
+      cargo test --release

.cargo/config.toml

@@ -0,0 +1,2 @@
+[build]
+rustflags = ["--cfg", "tokio_unstable"]

.github/workflows/ci.yml

@@ -0,0 +1,39 @@
+name: Test and build
+
+on:
+  push:
+    branches:
+      - master
+
+jobs:
+  test_nostr-rs-relay:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Update local toolchain
+        run: |
+          sudo apt-get install -y protobuf-compiler
+          rustup update
+          rustup component add clippy
+          rustup install nightly
+
+      - name: Toolchain info
+        run: |
+          cargo --version --verbose
+          rustc --version
+          cargo clippy --version
+
+      # - name: Lint
+      #   run: |
+      #     cargo fmt -- --check
+      #     cargo clippy -- -D warnings
+
+      - name: Test
+        run: |
+          cargo check
+          cargo test --all
+
+      - name: Build
+        run: |
+          cargo build --release --locked

.gitignore

@@ -1,2 +1,5 @@
-/target
+**/target/
 nostr.db
+nostr.db-*
+justfile
+result

.pre-commit-config.yaml

@@ -0,0 +1,16 @@
+# See https://pre-commit.com for more information
+# See https://pre-commit.com/hooks.html for more hooks
+repos:
+- repo: https://github.com/pre-commit/pre-commit-hooks
+  rev: v4.3.0
+  hooks:
+  - id: trailing-whitespace
+  - id: end-of-file-fixer
+  - id: check-yaml
+  - id: check-added-large-files
+- repo: https://github.com/doublify/pre-commit-rust
+  rev: v1.0
+  hooks:
+#  - id: fmt
+  - id: cargo-check
+  - id: clippy

Cargo.toml

@@ -1,32 +1,68 @@
 [package]
 name = "nostr-rs-relay"
-version = "0.6.2"
+version = "0.9.0"
 edition = "2021"
+authors = ["Greg Heartsfield <scsibug@imap.cc>"]
+description = "A relay implementation for the Nostr protocol"
+readme = "README.md"
+homepage = "https://sr.ht/~gheartsfield/nostr-rs-relay/"
+repository = "https://git.sr.ht/~gheartsfield/nostr-rs-relay"
+license = "MIT"
+keywords = ["nostr", "server"]
+categories = ["network-programming", "web-programming"]
 
 [dependencies]
-log = "^0.4"
-env_logger = "^0.9"
-tokio = { version = "^1.16", features = ["full"] }
-futures = "^0.3"
-futures-util = "^0.3"
-tokio-tungstenite = "^0.17"
-tungstenite = "^0.17"
-thiserror = "^1"
-uuid = { version = "^0.8", features = ["v4"] }
-config = { version = "^0.12", features = ["toml"] }
-bitcoin_hashes = { version = "^0.10", features = ["serde"] }
-secp256k1 = {version = "^0.21", features = ["rand", "rand-std", "serde", "bitcoin_hashes"] }
-serde = { version = "^1.0", features = ["derive"] }
-serde_json = {version = "^1.0", features = ["preserve_order"]}
-hex = "^0.4"
-rusqlite = { version = "^0.26", features = ["limits","bundled"]}
-r2d2 = "^0.8"
-r2d2_sqlite = "^0.19"
-lazy_static = "^1.4"
-governor = "^0.4"
-nonzero_ext = "^0.3"
+clap = { version = "4.0.32", features = ["env", "default", "derive"]}
+tracing = "0.1.37"
+tracing-appender = "0.2.2"
+tracing-subscriber = "0.3.16"
+tokio = { version = "1", features = ["full", "tracing", "signal"] }
+prost = "0.11"
+tonic = "0.8.3"
+console-subscriber = "0.1.8"
+futures = "0.3"
+futures-util = "0.3"
+tokio-tungstenite = "0.17"
+tungstenite = "0.17"
+thiserror = "1"
+uuid = { version = "1.1.2", features = ["v4"] }
+config = { version = "0.12", features = ["toml"] }
+bitcoin_hashes = { version = "0.10", features = ["serde"] }
+secp256k1 = {version = "0.21", features = ["rand", "rand-std", "serde", "bitcoin_hashes"] }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = {version = "1.0", features = ["preserve_order"]}
+hex = "0.4"
+rusqlite = { version = "0.26", features = ["limits","bundled","modern_sqlite", "trace"]}
+r2d2 = "0.8"
+r2d2_sqlite = "0.19"
+lazy_static = "1.4"
+governor = "0.4"
+nonzero_ext = "0.3"
 hyper = { version="0.14", features=["client", "server","http1","http2","tcp"] }
-hyper-tls = "^0.5"
-http = { version = "^0.2" }
-parse_duration = "^2"
-rand = "^0.8"
+hyper-rustls = { version = "0.24" }
+http = { version = "0.2" }
+parse_duration = "2"
+rand = "0.8"
+const_format = "0.2.28"
+regex = "1"
+async-trait = "0.1.60"
+async-std = "1.12.0"
+sqlx = { version ="0.6.2", features=["runtime-tokio-rustls", "postgres", "chrono"]}
+chrono = "0.4.23"
+prometheus = "0.13.3"
+indicatif = "0.17.3"
+bech32 = "0.9.1"
+url = "2.3.1"
+qrcode = { version = "0.12.0", default-features = false, features = ["svg"] }
+nostr = { version = "0.18.0", default-features = false, features = ["base", "nip04", "nip19"] }
+log = "0.4"
+cln-rpc = "0.1.9"
+
+[target.'cfg(all(not(target_env = "msvc"), not(target_os = "openbsd")))'.dependencies]
+tikv-jemallocator = "0.5"
+
+[dev-dependencies]
+anyhow = "1"
+
+[build-dependencies]
+tonic-build = { version="0.8.3", features = ["prost"] }

Dockerfile

@@ -1,18 +1,28 @@
-FROM docker.io/library/rust:1.63.0@sha256:d7e3f69edcdcd03b145d8d9361765b816656755e49c1c1fe28224a4505f91b0a as builder
-
+FROM docker.io/library/rust:1-bookworm as builder
+RUN apt-get update \
+    && apt-get install -y cmake protobuf-compiler \
+    && rm -rf /var/lib/apt/lists/*
+RUN USER=root cargo install cargo-auditable
 RUN USER=root cargo new --bin nostr-rs-relay
 WORKDIR ./nostr-rs-relay
 COPY ./Cargo.toml ./Cargo.toml
 COPY ./Cargo.lock ./Cargo.lock
-RUN cargo build --release
+# build dependencies only (caching)
+RUN cargo auditable build --release --locked
+# get rid of starter project code
 RUN rm src/*.rs
 
+# copy project source code
 COPY ./src ./src
+COPY ./proto ./proto
+COPY ./build.rs ./build.rs
 
+# build auditable release using locked deps
 RUN rm ./target/release/deps/nostr*relay*
-RUN cargo build --release
+RUN cargo auditable build --release --locked
+
+FROM docker.io/library/debian:bookworm-slim
 
-FROM docker.io/library/debian:bullseye-20220801-slim@sha256:139a42fa3bde3e5bad6ae912aaaf2103565558a7a73afe6ce6ceed6e46a6e519
 ARG APP=/usr/src/app
 ARG APP_DATA=/usr/src/app/db
 RUN apt-get update \
@@ -36,7 +46,7 @@ RUN chown -R $APP_USER:$APP_USER ${APP}
 USER $APP_USER
 WORKDIR ${APP}
 
-ENV RUST_LOG=info
+ENV RUST_LOG=info,nostr_rs_relay=info
 ENV APP_DATA=${APP_DATA}
 
 CMD ./nostr-rs-relay --db ${APP_DATA}

README.md

@@ -1,28 +1,42 @@
 # [nostr-rs-relay](https://git.sr.ht/~gheartsfield/nostr-rs-relay)
 
-This is a [nostr](https://github.com/fiatjaf/nostr) relay, written in
-Rust.  It currently supports the entire relay protocol, and has a
-SQLite persistence layer.
+This is a [nostr](https://github.com/nostr-protocol/nostr) relay,
+written in Rust.  It currently supports the entire relay protocol, and
+persists data with SQLite.  There is experimental support for
+Postgresql.
 
 The project master repository is available on
 [sourcehut](https://sr.ht/~gheartsfield/nostr-rs-relay/), and is
 mirrored on [GitHub](https://github.com/scsibug/nostr-rs-relay).
 
+[![builds.sr.ht status](https://builds.sr.ht/~gheartsfield/nostr-rs-relay/commits/master.svg)](https://builds.sr.ht/~gheartsfield/nostr-rs-relay/commits/master?)
+
+![Github CI](https://github.com/scsibug/nostr-rs-relay/actions/workflows/ci.yml/badge.svg)
+
+
 ## Features
 
-NIPs with a relay-specific implementation are listed here.
+[NIPs](https://github.com/nostr-protocol/nips) with a relay-specific implementation are listed here.
 
-- [x] NIP-01: Core event model
-- [x] NIP-01: Hide old metadata events
-- [x] NIP-01: Id/Author prefix search (_experimental_)
-- [x] NIP-02: Hide old contact list events
-- [ ] NIP-03: OpenTimestamps
-- [x] NIP-05: Mapping Nostr keys to DNS identifiers
-- [x] NIP-09: Event deletion
-- [x] NIP-11: Relay information document
-- [x] NIP-12: Generic tag search (_experimental_)
-- [x] NIP-15: End of stored events notice
-- [x] NIP-16: Replaceable and ephemeral events
+- [x] NIP-01: [Basic protocol flow description](https://github.com/nostr-protocol/nips/blob/master/01.md)
+  * Core event model
+  * Hide old metadata events
+  * Id/Author prefix search
+- [x] NIP-02: [Contact List and Petnames](https://github.com/nostr-protocol/nips/blob/master/02.md)
+- [ ] NIP-03: [OpenTimestamps Attestations for Events](https://github.com/nostr-protocol/nips/blob/master/03.md)
+- [x] NIP-05: [Mapping Nostr keys to DNS-based internet identifiers](https://github.com/nostr-protocol/nips/blob/master/05.md)
+- [x] NIP-09: [Event Deletion](https://github.com/nostr-protocol/nips/blob/master/09.md)
+- [x] NIP-11: [Relay Information Document](https://github.com/nostr-protocol/nips/blob/master/11.md)
+- [x] NIP-12: [Generic Tag Queries](https://github.com/nostr-protocol/nips/blob/master/12.md)
+- [x] NIP-15: [End of Stored Events Notice](https://github.com/nostr-protocol/nips/blob/master/15.md)
+- [x] NIP-16: [Event Treatment](https://github.com/nostr-protocol/nips/blob/master/16.md)
+- [x] NIP-20: [Command Results](https://github.com/nostr-protocol/nips/blob/master/20.md)
+- [x] NIP-22: [Event `created_at` limits](https://github.com/nostr-protocol/nips/blob/master/22.md) (_future-dated events only_)
+- [ ] NIP-26: [Event Delegation](https://github.com/nostr-protocol/nips/blob/master/26.md) (_implemented, but currently disabled_)
+- [x] NIP-28: [Public Chat](https://github.com/nostr-protocol/nips/blob/master/28.md)
+- [x] NIP-33: [Parameterized Replaceable Events](https://github.com/nostr-protocol/nips/blob/master/33.md)
+- [x] NIP-40: [Expiration Timestamp](https://github.com/nostr-protocol/nips/blob/master/40.md)
+- [x] NIP-42: [Authentication of clients to relays](https://github.com/nostr-protocol/nips/blob/master/42.md)
 
 ## Quick Start
 
@@ -31,15 +45,32 @@ application.  Use a bind mount to store the SQLite database outside of
 the container image, and map the container's 8080 port to a host port
 (7000 in the example below).
 
+The examples below start a rootless podman container, mapping a local
+data directory and config file.
+
 ```console
-$ docker build -t nostr-rs-relay .
+$ podman build --pull -t nostr-rs-relay .
 
-$ docker run -it -p 7000:8080 \
-  --mount src=$(pwd)/data,target=/usr/src/app/db,type=bind nostr-rs-relay
+$ mkdir data
 
-[2021-12-31T19:58:31Z INFO  nostr_rs_relay] listening on: 0.0.0.0:8080
-[2021-12-31T19:58:31Z INFO  nostr_rs_relay::db] opened database "/usr/src/app/db/nostr.db" for writing
-[2021-12-31T19:58:31Z INFO  nostr_rs_relay::db] DB version = 2
+$ podman unshare chown 100:100 data
+
+$ podman run -it --rm -p 7000:8080 \
+  --user=100:100 \
+  -v $(pwd)/data:/usr/src/app/db:Z \
+  -v $(pwd)/config.toml:/usr/src/app/config.toml:ro,Z \
+  --name nostr-relay nostr-rs-relay:latest
+
+Nov 19 15:31:15.013  INFO nostr_rs_relay: Starting up from main
+Nov 19 15:31:15.017  INFO nostr_rs_relay::server: listening on: 0.0.0.0:8080
+Nov 19 15:31:15.019  INFO nostr_rs_relay::server: db writer created
+Nov 19 15:31:15.019  INFO nostr_rs_relay::server: control message listener started
+Nov 19 15:31:15.019  INFO nostr_rs_relay::db: Built a connection pool "event writer" (min=1, max=4)
+Nov 19 15:31:15.019  INFO nostr_rs_relay::db: opened database "/usr/src/app/db/nostr.db" for writing
+Nov 19 15:31:15.019  INFO nostr_rs_relay::schema: DB version = 0
+Nov 19 15:31:15.054  INFO nostr_rs_relay::schema: database pragma/schema initialized to v7, and ready
+Nov 19 15:31:15.054  INFO nostr_rs_relay::schema: All migration scripts completed successfully.  Welcome to v7.
+Nov 19 15:31:15.521  INFO nostr_rs_relay::db: Built a connection pool "client query" (min=4, max=128)
 ```
 
 Use a `nostr` client such as
@@ -58,6 +89,48 @@ Text Note [81cf...2652] from 296a...9b92 5 seconds ago
 A pre-built container is also available on DockerHub:
 https://hub.docker.com/r/scsibug/nostr-rs-relay
 
+## Build and Run (without Docker)
+
+Building `nostr-rs-relay` requires an installation of Cargo & Rust: https://www.rust-lang.org/tools/install
+
+The following OS packages will be helpful; on Debian/Ubuntu:
+```console
+$ sudo apt-get install build-essential cmake protobuf-compiler pkg-config libssl-dev
+```
+
+On OpenBSD:
+```console
+$ doas pkg_add rust protobuf
+```
+
+Clone this repository, and then build a release version of the relay:
+
+```console
+$ git clone -q https://git.sr.ht/\~gheartsfield/nostr-rs-relay
+$ cd nostr-rs-relay
+$ cargo build -q -r
+```
+
+The relay executable is now located in
+`target/release/nostr-rs-relay`.  In order to run it with logging
+enabled, execute it with the `RUST_LOG` variable set:
+
+```console
+$ RUST_LOG=warn,nostr_rs_relay=info ./target/release/nostr-rs-relay
+Dec 26 10:31:56.455  INFO nostr_rs_relay: Starting up from main
+Dec 26 10:31:56.464  INFO nostr_rs_relay::server: listening on: 0.0.0.0:8080
+Dec 26 10:31:56.466  INFO nostr_rs_relay::server: db writer created
+Dec 26 10:31:56.466  INFO nostr_rs_relay::db: Built a connection pool "event writer" (min=1, max=2)
+Dec 26 10:31:56.466  INFO nostr_rs_relay::db: opened database "./nostr.db" for writing
+Dec 26 10:31:56.466  INFO nostr_rs_relay::schema: DB version = 11
+Dec 26 10:31:56.467  INFO nostr_rs_relay::db: Built a connection pool "maintenance writer" (min=1, max=2)
+Dec 26 10:31:56.467  INFO nostr_rs_relay::server: control message listener started
+Dec 26 10:31:56.468  INFO nostr_rs_relay::db: Built a connection pool "client query" (min=4, max=8)
+```
+
+You now have a running relay, on port `8080`.  Use a `nostr` client or
+`websocat` to connect and send/query for events.
+
 ## Configuration
 
 The sample [`config.toml`](config.toml) file demonstrates the
@@ -68,6 +141,7 @@ be mounted into a docker container like so:
 $ docker run -it -p 7000:8080 \
   --mount src=$(pwd)/config.toml,target=/usr/src/app/config.toml,type=bind \
   --mount src=$(pwd)/data,target=/usr/src/app/db,type=bind \
+  --mount src=$(pwd)/index.html,target=/usr/src/app/index.html,type=bind \
   nostr-rs-relay
 ```
 
@@ -78,14 +152,18 @@ settings.
 
 For examples of putting the relay behind a reverse proxy (for TLS
 termination, load balancing, and other features), see [Reverse
-Proxy](reverse-proxy.md).
+Proxy](docs/reverse-proxy.md).
 
 ## Dev Channel
 
 For development discussions, please feel free to use the [sourcehut
 mailing list](https://lists.sr.ht/~gheartsfield/nostr-rs-relay-devel).
-Or, drop by the [Nostr Telegram Channel](https://t.me/nostr_protocol).
 
 License
 ---
 This project is MIT licensed.
+
+External Documentation and Links
+---
+
+* [BlockChainCaffe's Nostr Relay Setup Guide](https://github.com/BlockChainCaffe/Nostr-Relay-Setup-Guide)

build.rs

@@ -0,0 +1,7 @@
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    tonic_build::configure()
+        .build_server(false)
+        .protoc_arg("--experimental_allow_proto3_optional")
+        .compile(&["proto/nauthz.proto"], &["proto"])?;
+    Ok(())
+}

config.toml

@@ -10,25 +10,78 @@ name = "nostr-rs-relay"
 # Description
 description = "A newly created nostr-rs-relay.\n\nCustomize this with your own info."
 
-# Administrative contact pubkey
+# Administrative contact pubkey (32-byte hex, not npub)
 #pubkey = "0c2d168a4ae8ca58c9f1ab237b5df682599c6c7ab74307ea8b05684b60405d41"
 
 # Administrative contact URI
 #contact = "mailto:contact@example.com"
 
+# Favicon location.  Relative to the current directory.  Assumes an
+# ICO format.
+#favicon = "favicon.ico"
+
+# URL of Relay's icon.
+#relay_icon = "https://example.test/img.png"
+
+# Path to custom relay html page
+#relay_page = "index.html"
+
+[diagnostics]
+# Enable tokio tracing (for use with tokio-console)
+#tracing = false
+
 [database]
+# Database engine (sqlite/postgres).  Defaults to sqlite.
+# Support for postgres is currently experimental.
+#engine = "sqlite"
+
 # Directory for SQLite files.  Defaults to the current directory.  Can
 # also be specified (and overriden) with the "--db dirname" command
 # line option.
-data_directory = "."
+#data_directory = "."
+
+# Use an in-memory database instead of 'nostr.db'.
+# Requires sqlite engine.
+# Caution; this will not survive a process restart!
+#in_memory = false
 
 # Database connection pool settings for subscribers:
 
 # Minimum number of SQLite reader connections
-#min_conn = 4
+#min_conn = 0
 
-# Maximum number of SQLite reader connections
-#max_conn = 128
+# Maximum number of SQLite reader connections.  Recommend setting this
+# to approx the number of cores.
+#max_conn = 8
+
+# Database connection string.  Required for postgres; not used for
+# sqlite.
+#connection = "postgresql://postgres:nostr@localhost:7500/nostr"
+
+# Optional database connection string for writing.  Use this for
+# postgres clusters where you want to separate reads and writes to
+# different nodes.  Ignore for single-database instances.
+#connection_write = "postgresql://postgres:nostr@localhost:7500/nostr"
+
+[logging]
+# Directory to store log files.  Log files roll over daily.
+#folder_path = "./log"
+#file_prefix = "nostr-relay"
+
+[grpc]
+# gRPC interfaces for externalized decisions and other extensions to
+# functionality.
+#
+# Events can be authorized through an external service, by providing
+# the URL below.  In the event the server is not accessible, events
+# will be permitted.  The protobuf3 schema used is available in
+# `proto/nauthz.proto`.
+# event_admission_server = "http://[::1]:50051"
+
+# If the event admission server denies writes
+# in any case (excluding spam filtering).
+# This is reflected in the relay information document.
+# restricts_write = true
 
 [network]
 # Bind to this network address
@@ -37,16 +90,45 @@ address = "0.0.0.0"
 # Listen on this port
 port = 8080
 
+# If present, read this HTTP header for logging client IP addresses.
+# Examples for common proxies, cloudflare:
+#remote_ip_header = "x-forwarded-for"
+#remote_ip_header = "cf-connecting-ip"
+
+# Websocket ping interval in seconds, defaults to 5 minutes
+#ping_interval = 300
+
 [options]
 # Reject events that have timestamps greater than this many seconds in
-# the future.  Defaults to rejecting anything greater than 30 minutes
-# from the current time.
+# the future.  Recommended to reject anything greater than 30 minutes
+# from the current time, but the default is to allow any date.
 reject_future_seconds = 1800
 
 [limits]
 # Limit events created per second, averaged over one minute.  Must be
-# an integer.  If not set (or set to 0), defaults to unlimited.
-#messages_per_sec = 0
+# an integer.  If not set (or set to 0), there is no limit.  Note:
+# this is for the server as a whole, not per-connection.
+#
+# Limiting event creation is highly recommended if your relay is
+# public!
+#
+#messages_per_sec = 5
+
+# Limit client subscriptions created, averaged over one minute.  Must
+# be an integer.  If not set (or set to 0), defaults to unlimited.
+# Strongly recommended to set this to a low value such as 10 to ensure
+# fair service.
+#subscriptions_per_min = 0
+
+# UNIMPLEMENTED...
+# Limit how many concurrent database connections a client can have.
+# This prevents a single client from starting too many expensive
+# database queries.  Must be an integer.  If not set (or set to 0),
+# defaults to unlimited (subject to subscription limits).
+#db_conns_per_client = 0
+
+# Limit blocking threads used for database connections.  Defaults to 16.
+#max_blocking_threads = 16
 
 # Limit the maximum size of an EVENT message.  Defaults to 128 KB.
 # Set to 0 for unlimited.
@@ -66,6 +148,21 @@ reject_future_seconds = 1800
 # backpressure to senders if writes are slow.
 #event_persist_buffer = 4096
 
+# Event kind blacklist. Events with these kinds will be discarded.
+#event_kind_blacklist = [
+#    70202,
+#]
+
+# Event kind allowlist. Events other than these kinds will be discarded.
+#event_kind_allowlist = [
+#    0, 1, 2, 3, 7, 40, 41, 42, 43, 44, 30023,
+#]
+
+# Rejects imprecise requests (kind only and author only etc)
+# This is a temperary measure to improve the adoption of outbox model
+# Its recommended to have this enabled
+limit_scrapers = false
+
 [authorization]
 # Pubkey addresses in this array are whitelisted for event publishing.
 # Only valid events by these authors will be accepted, if the variable
@@ -74,6 +171,10 @@ reject_future_seconds = 1800
 #  "35d26e4690cbe1a898af61cc3515661eb5fa763b57bd0b42e45099c8b32fd50f",
 #  "887645fef0ce0c3c1218d2f5d8e6132a19304cdc57cd20281d082f38cfea0072",
 #]
+# Enable NIP-42 authentication
+#nip42_auth = false
+# Send DMs (kind 4 and 44) and gift wraps (kind 1059) only to their authenticated recipients
+#nip42_dms = false
 
 [verified_users]
 # NIP-05 verification of users.  Can be "enabled" to require NIP-05
@@ -100,3 +201,53 @@ reject_future_seconds = 1800
 # How many consecutive failed checks before we give up on verifying
 # this author.
 #max_consecutive_failures = 20
+
+[pay_to_relay]
+# Enable pay to relay
+#enabled = false
+
+# Node interface to use
+#processor = "ClnRest/LNBits"
+
+# The cost to be admitted to relay
+#admission_cost = 4200
+
+# The cost in sats per post
+#cost_per_event = 0
+
+# Url of node api
+#node_url = "<node url>"
+
+# LNBits api secret
+#api_secret = "<ln bits api>"
+
+# Path to CLN rune
+#rune_path = "<rune path>"
+
+# Nostr direct message on signup
+#direct_message=false
+
+# Terms of service
+#terms_message = """
+#This service (and supporting services) are provided "as is", without warranty of any kind, express or implied.
+#
+#By using this service, you agree:
+#* Not to engage in spam or abuse the relay service
+#* Not to disseminate illegal content
+#* That requests to delete content cannot be guaranteed
+#* To use the service in compliance with all applicable laws
+#* To grant necessary rights to your content for unlimited time
+#* To be of legal age and have capacity to use this service
+#* That the service may be terminated at any time without notice
+#* That the content you publish may be removed at any time without notice
+#* To have your IP address collected to detect abuse or misuse
+#* To cooperate with the relay to combat abuse or misuse
+#* You may be exposed to content that you might find triggering or distasteful
+#* The relay operator is not liable for content produced by users of the relay
+#"""
+
+# Whether or not new sign ups should be allowed
+#sign_ups = false
+
+# optional if `direct_message=false`
+#secret_key = "<nostr nsec>"

contrib/nostr-rs-relay.service

@@ -0,0 +1,14 @@
+[Unit]
+Description=nostr-rs-relay
+
+[Service]
+User=REPLACE_WITH_YOUR_USERNAME
+WorkingDirectory=/var/lib/nostr-rs-relay
+Environment=RUST_LOG=warn,nostr_rs_relay=info
+ExecStart=/usr/bin/nostr-rs-relay --config /etc/nostr-rs-relay/config.toml
+TimeoutStopSec=10
+Restart=on-failure
+RestartSec=5
+
+[Install]
+WantedBy=multi-user.target

docs/database-maintenance.md

@@ -0,0 +1,129 @@
+# Database Maintenance
+
+`nostr-rs-relay` uses the SQLite embedded database to minimize
+dependencies and overall footprint of running a relay.  If traffic is
+light, the relay should just run with very little need for
+intervention.  For heavily trafficked relays, there are a number of
+steps that the operator may need to take to maintain performance and
+limit disk usage.
+
+This maintenance guide is current as of version `0.8.2`.  Future
+versions may incorporate and automate some of these steps.
+
+## Backing Up the Database
+
+To prevent data loss, the database should be backed up regularly.  The
+recommended method is to use the `sqlite3` command to perform an
+"Online Backup".  This can be done while the relay is running, queries
+can still run and events will be persisted during the backup.
+
+The following commands will perform a backup of the database to a
+dated file, and then compress to minimize size:
+
+```console
+BACKUP_FILE=/var/backups/nostr/`date +%Y%m%d_%H%M`.db
+sqlite3 -readonly /apps/nostr-relay/nostr.db ".backup $BACKUP_FILE"
+sqlite3 $BACKUP_FILE "vacuum;"
+bzip2 -9 $BACKUP_FILE
+```
+
+Nostr events are very compressible.  Expect a compression ratio on the
+order of 4:1, resulting in a 75% space saving.
+
+## Vacuuming the Database
+
+As the database is updated, it can become fragmented.  Performing a
+full `vacuum` will rebuild the entire database file, and can reduce
+space.  Running this may reduce the size of the database file,
+especially if a large amount of data was updated or deleted.
+
+```console
+vacuum;
+```
+
+## Clearing Hidden Events
+
+When events are deleted, the event is not actually removed from the
+database.  Instead, a flag `HIDDEN` is set to true for the event,
+which excludes it from search results.  High volume replacements from
+profile or other replaceable events are deleted, not hidden, in the
+current version of the relay.
+
+In the current version, removing hidden events should not result in
+significant space savings, but it can still be used if there is no
+desire to hold on to events that can never be re-broadcast.
+
+```console
+PRAGMA foreign_keys = ON;
+delete from event where HIDDEN=true;
+```
+
+## Manually Removing Events
+
+For a variety of reasons, an operator may wish to remove some events
+from the database.  The only way of achieving this today is with
+manually run SQL commands.
+
+It is recommended to have a good backup prior to manually running SQL
+commands!
+
+In all cases, it is mandatory to enable foreign keys, and this must be
+done for every connection.  Otherwise, you will likely orphan rows in
+the `tag` table.
+
+### Deleting Specific Event
+
+```console
+PRAGMA foreign_keys = ON;
+delete from event where event_hash=x'00000000000c1271675dc86e3e1dd1336827bccabb90dc4c9d3b4465efefe00e';
+```
+
+### Querying and Deleting All Events for Pubkey
+
+```console
+PRAGMA foreign_keys = ON;
+
+select lower(hex(author)) as author, count(*) as c from event group by author order by c asc;
+
+delete from event where author=x'000000000002c7831d9c5a99f183afc2813a6f69a16edda7f6fc0ed8110566e6';
+```
+
+### Querying and Deleting All Events of a Kind
+
+
+```console
+PRAGMA foreign_keys = ON;
+
+select printf('%7d', kind), count(*) as c from event group by kind order by c;
+
+delete from event where kind=70202;
+```
+
+### Deleting Old Events
+
+In this scenario, we wish to delete any event that has been stored by
+our relay for more than 1 month.  Crucially, this is based on when the
+event was stored, not when the event says it was created.  If an event
+has a `created` field of 2 years ago, but was first sent to our relay
+yesterday, it would not be deleted in this scenario.  Keep in mind, we
+do not track anything for re-broadcast events that we already have, so
+this is not a very effective way of implementing a "least recently
+seen" policy.
+
+```console
+PRAGMA foreign_keys = ON;
+
+DELETE FROM event WHERE first_seen < CAST(strftime('%s', date('now', '-30 day')) AS INT);
+```
+
+### Delete Profile Events with No Recent Events
+
+Many users create profiles, post a "hello world" event, and then never
+appear again (likely using an ephemeral keypair that was lost in the
+browser cache).  We can find these accounts and remove them after some
+time.
+
+```console
+PRAGMA foreign_keys = ON;
+TODO!
+```

docs/grpc-extensions.md

@@ -0,0 +1,79 @@
+# gRPC Extensions Design Document
+
+The relay will be extensible through gRPC endpoints, definable in the
+main configuration file.  These will allow external programs to host
+logic for deciding things such as, should this event be persisted,
+should this connection be allowed, and should this subscription
+request be registered.  The primary goal is allow for relay operator
+specific functionality that allows them to serve smaller communities
+and reduce spam and abuse.
+
+This will likely evolve substantially, the first goal is to get a
+basic one-way service that lets an externalized program decide on
+event persistence.  This does not represent the final state of gRPC
+extensibility in `nostr-rs-relay`.
+
+## Considerations
+
+Write event latency must not be significantly affected.  However, the
+primary reason we are implementing this is spam/abuse protection, so
+we are willing to tolerate some increase in latency if that protects
+us against outages!
+
+The interface should provide enough information to make simple
+decisions, without burdening the relay to do extra queries.  The
+decision endpoint will be mostly responsible for maintaining state and
+gathering additional details.
+
+## Design Overview
+
+A gRPC server may be defined in the `config.toml` file.  If it exists,
+the relay will attempt to connect to it and send a message for each
+`EVENT` command submitted by clients.  If a successful response is
+returned indicating the event is permitted, the relay continues
+processing the event as normal.  All existing whitelist, blacklist,
+and `NIP-05` validation checks are still performed and MAY still
+result in the event being rejected.  If a successful response is
+returned indicated the decision is anything other than permit, then
+the relay MUST reject the event, and return a command result to the
+user (using `NIP-20`) indicating the event was blocked (optionally
+providing a message).
+
+In the event there is an error in the gRPC interface, event processing
+proceeds as if gRPC was disabled (fail open).  This allows gRPC
+servers to be deployed with minimal chance of causing a full relay
+outage.
+
+## Design Details
+
+Currently one procedure call is supported, `EventAdmit`, in the
+`Authorization` service.  It accepts the following data in order to
+support authorization decisions:
+
+- The event itself
+- The client IP that submitted the event
+- The client's HTTP origin header, if one exists
+- The client's HTTP user agent header, if one exists
+- The public key of the client, if `NIP-42` authentication was
+  performed (not supported in the relay yet!)
+- The `NIP-05` associated with the event's public key, if it is known
+  to the relay
+
+A server providing authorization decisions will return the following:
+
+- A decision to permit or deny the event
+- An optional message that explains why the event was denied, to be
+  transmitted to the client
+
+## Security Issues
+
+There is little attempt to secure this interface, since it is intended
+for use processes running on the same host.  It is recommended to
+ensure that the gRPC server providing the API is not exposed to the
+public Internet.  Authorization server implementations should have
+their own security reviews performed.
+
+A slow gRPC server could cause availability issues for event
+processing, since this is performed on a single thread.  Avoid any
+expensive or long-running processes that could result from submitted
+events, since any client can initiate a gRPC call to the service.

docs/pay-to-relay.md

@@ -0,0 +1,84 @@
+# Pay to Relay Design Document
+
+The relay with use payment as a form of spam prevention. In order to post to the relay a user must pay a set rate. There is also the option to require a payment for each note posted to the relay. There is no cost to read from the relay.
+
+## Configuration
+
+Currently, [LNBits](https://github.com/lnbits/lnbits) is implemented as the payment processor.  LNBits exposes a simple API for creating invoices, to use this API create a wallet and on the right side find "API info" you will need to add the invoice/read key to this relays config file.
+
+The below configuration will need to be added to config.toml
+```
+[pay_to_relay]
+# Enable pay to relay
+enabled = true
+# The cost to be admitted to relay
+admission_cost = 1000
+# The cost in sats per post
+cost_per_event = 0
+# Url of lnbits api
+node_url = "https://<IP of node>:5001/api/v1/payments"
+# LNBits api secret
+api_secret = "<LNbits api key>"
+# Terms of service
+terms_message = """This service ....
+"""
+# Whether or not new sign ups should be allowed
+sign_ups = true
+secret_key = "<nostr secret key to send dms>"
+```
+
+The LNBits instance must have a signed HTTPS a self signed certificate will not work.
+
+## Design Overview
+
+### Concepts
+
+All authors are initially not admitted to write to the relay.  There are two ways to gain access write to the relay. The first is by attempting to post the the relay, upon receiving an event from an author that is not admitted, the relay will send a direct message including the terms of service of the relay and a lighting invoice for the admission cost.  Once this invoice is paid the author can write to the relay. For this method to work the author must be reading from the relay. An author can also pay and accept the terms of service via a webpage `https://<relay-url>/join`.
+
+## Design Details
+
+Authors are stored in a dedicated table. This tracks:
+
+* `pubkey`
+* `is_admitted` whether on no the admission invoice has been paid, accepting the terms of service.
+* `balance` the current balance in sats of the author, used if there is a cost per post
+* `tos_accepted_at` the timestamp of when the author accepted the tos
+
+Invoice information is stored in a dedicated table. This tracks:
+* `payment_hash` the payment hash of the lighting invoice
+* `pubkey` of the author the invoice is issued to
+* `invoice` bolt11 invoice
+* `amount` in sats
+* `status` (Paid/Unpaid/Expired)
+* `description`
+* `created_at` timestamp of creation
+* `confirmed_at` timestamp of payment
+
+### Event Handling
+
+If "pay to relay" is enabled, all incoming events are evaluated to determine whether the author is on the relay's whitelist or if they have paid the admission fee and accepted the terms. If "pay per note" is enabled, there is an additional check to ensure that the author has enough balance, which is then reduced by the cost per note. If the author is on the whitelist, this balance check is not necessary.
+
+### Integration
+
+We have an existing database writer thread, which receives events and
+attempts to persist them to disk.  Once validated and persisted, these
+events are broadcast to all subscribers.
+
+When "pay to relay" is enabled, the writer must check if the author is admitted to post. If the author is not admitted to post the event is forwarded to the payment module. Where an invoice is generated, persisted and broadcast as an direct message to the author.
+
+### Threat Scenarios
+
+Some of these mitigation's are fully implemented, others are documented
+simply to demonstrate a mitigation is possible.
+
+### Sign up Spamming
+
+*Threat*: An attacker generates a large number of new pubkeys publishing to the relays. Causing a large number of new invoices to be created for each new pubkey.
+
+*Mitigation*: Rate limit number of new sign ups
+
+### Admitted Author Spamming
+
+*Threat*: An attacker gains write access by paying the admission fee, and then floods the relay with a large number of spam events.
+
+*Mitigation*: The attacker's admission can be revoked and their admission fee will not be refunded. Enabling "cost per event" and increasing the admission cost can also discourage this type of behavior.

docs/reverse-proxy.md

@@ -0,0 +1,199 @@
+# Reverse Proxy Setup Guide
+
+It is recommended to run `nostr-rs-relay` behind a reverse proxy such
+as `haproxy`, `nginx` or `traefik` to provide TLS termination.  Simple examples
+for `haproxy`, `nginx` and `traefik` configurations are documented here.
+
+## Minimal HAProxy Configuration
+
+Assumptions:
+
+* HAProxy version is `2.4.10` or greater (older versions not tested).
+* Hostname for the relay is `relay.example.com`.
+* Your relay should be available over wss://relay.example.com
+* Your (NIP-11) relay info page should be available on https://relay.example.com
+* SSL certificate is located in `/etc/certs/example.com.pem`.
+* Relay is running on port 8080.
+* Limit connections to 400 concurrent.
+* HSTS (HTTP Strict Transport Security) is desired.
+* Only TLS 1.2 or greater is allowed.
+
+```
+global
+    ssl-default-bind-ciphersuites TLS_AES_128_GCM_SHA256:TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256
+    ssl-default-bind-options prefer-client-ciphers no-sslv3 no-tlsv10 no-tlsv11 no-tls-tickets
+
+frontend fe_prod
+    mode    http
+    bind    :443 ssl crt /etc/certs/example.com.pem alpn h2,http/1.1
+    bind    :80
+    http-request set-header X-Forwarded-Proto https if { ssl_fc }
+    redirect scheme https code 301 if !{ ssl_fc }
+    acl host_relay hdr(host) -i -m beg relay.example.com
+    use_backend relay if host_relay
+    # HSTS (1 year)
+    http-response set-header Strict-Transport-Security max-age=31536000
+
+backend relay
+    mode http
+    timeout connect 5s
+    timeout client 50s
+    timeout server 50s
+    timeout tunnel 1h
+    timeout client-fin 30s
+    option tcp-check
+    default-server maxconn 400 check inter 20s fastinter 1s
+    server relay 127.0.0.1:8080
+```
+
+### HAProxy Notes
+
+You may experience WebSocket connection problems with Firefox if
+HTTP/2 is enabled, for older versions of HAProxy (2.3.x).  Either
+disable HTTP/2 (`h2`), or upgrade HAProxy.
+
+## Bare-bones Nginx Configuration
+
+Assumptions:
+
+* `Nginx` version is `1.18.0` (other versions not tested).
+* Hostname for the relay is `relay.example.com`.
+* SSL certificate and key are located at `/etc/letsencrypt/live/relay.example.com/`.
+* Relay is running on port `8080`.
+
+```
+http {
+    server {
+        listen 443 ssl;
+        server_name relay.example.com;
+        ssl_certificate /etc/letsencrypt/live/relay.example.com/fullchain.pem;
+        ssl_certificate_key /etc/letsencrypt/live/relay.example.com/privkey.pem;
+        ssl_protocols TLSv1.3 TLSv1.2;
+        ssl_prefer_server_ciphers on;
+        ssl_ecdh_curve secp521r1:secp384r1;
+        ssl_ciphers EECDH+AESGCM:EECDH+AES256;
+
+        # Optional Diffie-Helmann parameters
+        # Generate with openssl dhparam -out /etc/ssl/certs/dhparam.pem 4096
+        #ssl_dhparam /etc/ssl/certs/dhparam.pem;
+
+        ssl_session_cache shared:TLS:2m;
+        ssl_buffer_size 4k;
+
+        # OCSP stapling
+        ssl_stapling on;
+        ssl_stapling_verify on;
+        resolver 1.1.1.1 1.0.0.1 [2606:4700:4700::1111] [2606:4700:4700::1001]; # Cloudflare
+
+        # Set HSTS to 365 days
+        add_header Strict-Transport-Security 'max-age=31536000; includeSubDomains; preload' always;
+        keepalive_timeout 70;
+
+        location / {
+            proxy_pass http://localhost:8080;
+            proxy_http_version 1.1;
+            proxy_read_timeout 1d;
+            proxy_send_timeout 1d;
+            proxy_set_header Upgrade $http_upgrade;
+            proxy_set_header Connection "Upgrade";
+            proxy_set_header Host $host;
+        }
+    }
+}
+```
+
+### Nginx Notes
+
+The above configuration was tested on `nginx` `1.18.0` on `Ubuntu` `20.04` and `22.04`
+
+For help installing `nginx` on `Ubuntu`, see [this guide](https://www.digitalocean.com/community/tutorials/how-to-install-nginx-on-ubuntu-20-04).
+
+For guidance on using `letsencrypt` to obtain a cert on `Ubuntu`, including an `nginx` plugin, see [this post](https://www.digitalocean.com/community/tutorials/how-to-secure-nginx-with-let-s-encrypt-on-ubuntu-20-04).
+
+
+## Example Traefik Configuration
+
+Assumptions:
+
+* `Traefik` version is `2.9` (other versions not tested).
+* `Traefik` is used for provisioning of Let's Encrypt certificates.
+* `Traefik` is running in `Docker`, using `docker compose` and labels for the static configuration. An equivalent setup using a Traefik config file is possible too (but not covered here).
+* Strict Transport Security is enabled.
+* Hostname for the relay is `relay.example.com`, email address for ACME certificates provider is `name@example.com`.
+* ipv6 is enabled, a viable private ipv6 subnet is specified in the example below.
+* Relay is running on port `8080`.
+
+```
+version: '3'
+
+networks:
+  nostr:
+    enable_ipv6: true
+    ipam:
+      config:
+        - subnet: fd00:db8:a::/64
+          gateway: fd00:db8:a::1
+
+services:
+  traefik:
+    image: traefik:v2.9
+    networks:
+      nostr:
+    command:
+      - "--log.level=ERROR"
+      # letsencrypt configuration
+      - "--certificatesResolvers.http.acme.email==name@example.com"
+      - "--certificatesResolvers.http.acme.storage=/certs/acme.json"
+      - "--certificatesResolvers.http.acme.httpChallenge.entryPoint=http"
+      # define entrypoints
+      - "--entryPoints.http.address=:80"
+      - "--entryPoints.http.http.redirections.entryPoint.to=https"
+      - "--entryPoints.http.http.redirections.entryPoint.scheme=https"
+      - "--entryPoints.https.address=:443"
+      - "--entryPoints.https.forwardedHeaders.insecure=true"
+      - "--entryPoints.https.proxyProtocol.insecure=true"
+      # docker provider (get configuration from container labels)
+      - "--providers.docker.endpoint=unix:///var/run/docker.sock"
+      - "--providers.docker.exposedByDefault=false"
+      - "--providers.file.directory=/config"
+      - "--providers.file.watch=true"
+    ports:
+      - "80:80"
+      - "443:443"
+    volumes:
+      - "/var/run/docker.sock:/var/run/docker.sock:ro"
+      - "$(pwd)/traefik/certs:/certs"
+      - "$(pwd)/traefik/config:/config"
+    logging:
+      driver: "local"
+    restart: always
+
+  # example nostr config. only labels: section is relevant for Traefik config
+  nostr:
+   image: nostr-rs-relay:latest
+   container_name: nostr-relay
+   networks:
+     nostr:
+   restart: always
+   user: 100:100
+   volumes:
+   - '$(pwd)/nostr/data:/usr/src/app/db:Z'
+   - '$(pwd)/nostr/config/config.toml:/usr/src/app/config.toml:ro,Z'
+   labels:
+     - "traefik.enable=true"
+     - "traefik.http.routers.nostr.entrypoints=https"
+     - "traefik.http.routers.nostr.rule=Host(`relay.example.com`)"
+     - "traefik.http.routers.nostr.tls.certresolver=http"
+     - "traefik.http.routers.nostr.service=nostr"
+     - "traefik.http.services.nostr.loadbalancer.server.port=8080"
+     - "traefik.http.services.nostr.loadbalancer.passHostHeader=true"
+     - "traefik.http.middlewares.nostr.headers.sslredirect=true"
+     - "traefik.http.middlewares.nostr.headers.stsincludesubdomains=true"
+     - "traefik.http.middlewares.nostr.headers.stspreload=true"
+     - "traefik.http.middlewares.nostr.headers.stsseconds=63072000"
+     - "traefik.http.routers.nostr.middlewares=nostr"
+```
+
+### Traefik Notes
+
+Traefik will take care of the provisioning and renewal of certificates. In case of an ipv4-only relay, simply detele the `enable_ipv6:` and `ipam:` entries in the `networks:` section of the docker-compose file.

docs/run-as-linux-system-process.md

@@ -0,0 +1,40 @@
+# Run as a linux system process
+
+Docker makes it easy to spin up and down environments but it's also possible to run `nostr-rs-relay` as a systemd linux process.
+This guide assumes you're on a Linux machine and that Rust is already installed.
+
+## Instructions
+
+### Build nostr-rs-relay from source
+Start by building the application from source. Here is how to do that:
+1. `git clone https://github.com/scsibug/nostr-rs-relay.git`
+2. `cd nostr-rs-relay`
+3. `cargo build --release`
+
+### Place the files where they belong
+We want to place the nostr-rs-relay binary and the config.toml file where they belong. While still in the root level of the nostr-rs-relay folder you cloned in last step, run the following commands:
+1. `sudo cp target/release/nostr-rs-relay /usr/local/bin/`
+2. `sudo mkdir /etc/nostr-rs-relay`
+2. `sudo cp config.toml /etc/nostr-rs-relay`
+
+### Create the Systemd service file
+We need to create a new Systemd service file. These files are placed in the `/etc/systemd/system/` folder where you will find many other services running.
+
+1. `sudo vim /etc/systemd/system/nostr-rs-relay.service`
+2. Paste in the contents of [this service file](../contrib/nostr-rs-relay.service). Remember to replace the `User` value with your own username.
+3. Save the file and exit your text editor
+
+
+### Run the service
+To get the service running, we need to reload the systemd daemon and enable the service.
+
+1. `sudo systemctl daemon-reload`
+2. `sudo systemctl start nostr-rs-relay.service`
+3. `sudo systemctl enable nostr-rs-relay.service`
+4. `sudo systemctl status nostr-rs-relay.service`
+
+
+### Tips
+
+#### Logs
+The application will write logs to the journal. To read it, execute `sudo journalctl -f -u nostr-rs-relay`

docs/user-verification-nip05.md

@@ -179,7 +179,7 @@ attempts to persist them to disk.  Once validated and persisted, these
 events are broadcast to all subscribers.
 
 When verification is enabled, the writer must check to ensure a valid,
-unexpired verification record exists for the auther.  All metadata
+unexpired verification record exists for the author.  All metadata
 events (regardless of verification status) are forwarded to a verifier
 module.  If the verifier determines a new verification record is
 needed, it is also responsible for persisting and broadcasting the

examples/nauthz/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "nauthz-server"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+# Common dependencies
+tokio = { version = "1.0", features = ["rt-multi-thread", "macros"] }
+prost = "0.11"
+tonic = "0.8.3"
+
+[build-dependencies]
+tonic-build = { version="0.8.3", features = ["prost"] }

examples/nauthz/build.rs

@@ -0,0 +1,7 @@
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    tonic_build::configure()
+        .build_server(true)
+        .protoc_arg("--experimental_allow_proto3_optional")
+        .compile(&["../../proto/nauthz.proto"], &["../../proto"])?;
+    Ok(())
+}

examples/nauthz/src/main.rs

@@ -0,0 +1,60 @@
+use tonic::{transport::Server, Request, Response, Status};
+
+use nauthz_grpc::authorization_server::{Authorization, AuthorizationServer};
+use nauthz_grpc::{Decision, EventReply, EventRequest};
+
+pub mod nauthz_grpc {
+    tonic::include_proto!("nauthz");
+}
+
+#[derive(Default)]
+pub struct EventAuthz {
+    allowed_kinds: Vec<u64>,
+}
+
+#[tonic::async_trait]
+impl Authorization for EventAuthz {
+    async fn event_admit(
+        &self,
+        request: Request<EventRequest>,
+    ) -> Result<Response<EventReply>, Status> {
+        let reply;
+        let req = request.into_inner();
+        let event = req.event.unwrap();
+        let content_prefix: String = event.content.chars().take(40).collect();
+        println!("recvd event, [kind={}, origin={:?}, nip05_domain={:?}, tag_count={}, content_sample={:?}]",
+                 event.kind, req.origin, req.nip05.map(|x| x.domain), event.tags.len(), content_prefix);
+        // Permit any event with a whitelisted kind
+        if self.allowed_kinds.contains(&event.kind) {
+            println!("This looks fine! (kind={})", event.kind);
+            reply = nauthz_grpc::EventReply {
+                decision: Decision::Permit as i32,
+                message: None,
+            };
+        } else {
+            println!("Blocked! (kind={})", event.kind);
+            reply = nauthz_grpc::EventReply {
+                decision: Decision::Deny as i32,
+                message: Some(format!("kind {} not permitted", event.kind)),
+            };
+        }
+        Ok(Response::new(reply))
+    }
+}
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let addr = "[::1]:50051".parse().unwrap();
+
+    // A simple authorization engine that allows kinds 0-3
+    let checker = EventAuthz {
+        allowed_kinds: vec![0, 1, 2, 3],
+    };
+    println!("EventAuthz Server listening on {}", addr);
+    // Start serving
+    Server::builder()
+        .add_service(AuthorizationServer::new(checker))
+        .serve(addr)
+        .await?;
+    Ok(())
+}

flake.lock

@@ -0,0 +1,82 @@
+{
+  "nodes": {
+    "crane": {
+      "inputs": {
+        "nixpkgs": [
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1719249093,
+        "narHash": "sha256-0q1haa3sw6GbmJ+WhogMnducZGjEaCa/iR6hF2vq80I=",
+        "owner": "ipetkov",
+        "repo": "crane",
+        "rev": "9791c77eb7e98b8d8ac5b0305d47282f994411ca",
+        "type": "github"
+      },
+      "original": {
+        "owner": "ipetkov",
+        "repo": "crane",
+        "type": "github"
+      }
+    },
+    "flake-utils": {
+      "inputs": {
+        "systems": "systems"
+      },
+      "locked": {
+        "lastModified": 1710146030,
+        "narHash": "sha256-SZ5L6eA7HJ/nmkzGG7/ISclqe6oZdOZTNoesiInkXPQ=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "b1d9ab70662946ef0850d488da1c9019f3a9752a",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1719254875,
+        "narHash": "sha256-ECni+IkwXjusHsm9Sexdtq8weAq/yUyt1TWIemXt3Ko=",
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "rev": "2893f56de08021cffd9b6b6dfc70fd9ccd51eb60",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nixos",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "crane": "crane",
+        "flake-utils": "flake-utils",
+        "nixpkgs": "nixpkgs"
+      }
+    },
+    "systems": {
+      "locked": {
+        "lastModified": 1681028828,
+        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
+        "owner": "nix-systems",
+        "repo": "default",
+        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-systems",
+        "repo": "default",
+        "type": "github"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

flake.nix

@@ -0,0 +1,44 @@
+{
+  description = "Nostr Relay written in Rust";
+
+  inputs = {
+    nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable";
+
+    flake-utils.url = "github:numtide/flake-utils";
+
+    crane = {
+      url = "github:ipetkov/crane";
+      inputs.nixpkgs.follows = "nixpkgs";
+    };
+  };
+
+  outputs = inputs@{ self, ... }:
+    inputs.flake-utils.lib.eachDefaultSystem (system:
+      let
+        pkgs = inputs.nixpkgs.legacyPackages.${system};
+        craneLib = inputs.crane.mkLib pkgs;
+        src = pkgs.lib.cleanSourceWith {
+          src = ./.;
+          filter = path: type:
+            (pkgs.lib.hasSuffix "\.proto" path) ||
+            # Default filter from crane (allow .rs files)
+            (craneLib.filterCargoSources path type)
+          ;
+        };
+        crate = craneLib.buildPackage {
+          name = "nostr-rs-relay";
+          inherit src;
+          nativeBuildInputs = [ pkgs.pkg-config pkgs.protobuf ];
+        };
+      in
+      {
+        checks = {
+          inherit crate;
+        };
+        packages.default = crate;
+        formatter = pkgs.nixpkgs-fmt;
+        devShells.default = craneLib.devShell {
+          checks = self.checks.${system};
+        };
+      });
+}

proto/nauthz.proto

@@ -0,0 +1,60 @@
+syntax = "proto3";
+
+// Nostr Authorization Services
+package nauthz;
+
+// Authorization for actions against a relay
+service Authorization {
+  // Determine if an event should be admitted to the relay
+  rpc EventAdmit(EventRequest) returns (EventReply) {}
+}
+
+message Event {
+  bytes id = 1;                // 32-byte SHA256 hash of serialized event
+  bytes pubkey = 2;            // 32-byte public key of event creator
+  fixed64 created_at = 3;      // UNIX timestamp provided by event creator
+  uint64 kind = 4;             // event kind
+  string content = 5;          // arbitrary event contents
+  repeated TagEntry tags = 6;  // event tag array
+  bytes sig = 7;               // 32-byte signature of the event id
+  // Individual values for a single tag
+  message TagEntry {
+    repeated string values = 1;
+  }
+}
+
+// Event data and metadata for authorization decisions
+message EventRequest {
+  Event event =
+      1;  // the event to be admitted for further relay processing
+  optional string ip_addr =
+      2;  // IP address of the client that submitted the event
+  optional string origin =
+      3;  // HTTP origin header from the client, if one exists
+  optional string user_agent =
+      4;  // HTTP user-agent header from the client, if one exists
+  optional bytes auth_pubkey =
+      5;  // the public key associated with a NIP-42 AUTH'd session, if
+          // authentication occurred
+  optional Nip05Name nip05 =
+      6; // NIP-05 address associated with the event pubkey, if it is
+         // known and has been validated by the relay
+  // A NIP_05 verification record
+  message Nip05Name {
+    string local = 1;
+    string domain = 2;
+  }
+}
+
+// A permit or deny decision
+enum Decision {
+  DECISION_UNSPECIFIED = 0;
+  DECISION_PERMIT = 1; // Admit this event for further processing
+  DECISION_DENY = 2; // Deny persisting or propagating this event
+}
+
+// Response to a event authorization request
+message EventReply {
+  Decision decision = 1;       // decision to enforce
+  optional string message = 2; // informative message for the client
+}

reverse-proxy.md

@@ -1,53 +0,0 @@
-# Reverse Proxy Setup Guide
-
-It is recommended to run `nostr-rs-relay` behind a reverse proxy such
-as `haproxy` or `nginx` to provide TLS termination.  A simple example
-of an `haproxy` configuration is documented here.
-
-## Minimal HAProxy Configuration
-
-Assumptions:
-
-* HAProxy version is `2.4.10` or greater (older versions not tested).
-* Hostname for the relay is `relay.example.com`.
-* Your relay should be available over wss://relay.example.com
-* Your (NIP-11) relay info page should be available on https://relay.example.com
-* SSL certificate is located in `/etc/certs/example.com.pem`.
-* Relay is running on port 8080.
-* Limit connections to 400 concurrent.
-* HSTS (HTTP Strict Transport Security) is desired.
-* Only TLS 1.2 or greater is allowed.
-
-```
-global
-    ssl-default-bind-ciphersuites TLS_AES_128_GCM_SHA256:TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256
-    ssl-default-bind-options prefer-client-ciphers no-sslv3 no-tlsv10 no-tlsv11 no-tls-tickets
-
-frontend fe_prod
-    mode    http
-    bind    :443 ssl crt /etc/certs/example.com.pem alpn h2,http/1.1
-    bind    :80
-    http-request set-header X-Forwarded-Proto https if { ssl_fc }
-    redirect scheme https code 301 if !{ ssl_fc }
-    acl host_relay hdr(host) -i relay.example.com
-    use_backend relay if host_relay
-    # HSTS (1 year)
-    http-response set-header Strict-Transport-Security max-age=31536000
-
-backend relay
-    mode http
-    timeout connect 5s
-    timeout client 50s
-    timeout server 50s
-    timeout tunnel 1h
-    timeout client-fin 30s
-    option tcp-check
-    default-server maxconn 400 check inter 20s fastinter 1s
-    server relay 127.0.0.1:8080
-```
-
-### Notes
-
-You may experience WebSocket connection problems with Firefox if
-HTTP/2 is enabled, for older versions of HAProxy (2.3.x).  Either
-disable HTTP/2 (`h2`), or upgrade HAProxy.

rustfmt.toml

@@ -1 +1,4 @@
-edition = "2018"
+edition = "2021"
+#max_width = 140
+#chain_width = 100
+#fn_call_width = 100

src/bin/bulkloader.rs

@@ -0,0 +1,180 @@
+use nostr_rs_relay::config;
+use nostr_rs_relay::error::{Error, Result};
+use nostr_rs_relay::event::{single_char_tagname, Event};
+use nostr_rs_relay::repo::sqlite::{build_pool, PooledConnection};
+use nostr_rs_relay::repo::sqlite_migration::{curr_db_version, DB_VERSION};
+use nostr_rs_relay::utils::is_lower_hex;
+use rusqlite::params;
+use rusqlite::{OpenFlags, Transaction};
+use std::io;
+use std::path::Path;
+use std::sync::mpsc;
+use std::thread;
+use tracing::info;
+
+/// Bulk load JSONL data from STDIN to the database specified in config.toml (or ./nostr.db as a default).
+/// The database must already exist, this will not create a new one.
+/// Tested against schema v13.
+pub fn main() -> Result<()> {
+    let _trace_sub = tracing_subscriber::fmt::try_init();
+    println!("Nostr-rs-relay Bulk Loader");
+    // check for a database file, or create one.
+    let settings = config::Settings::new(&None)?;
+    if !Path::new(&settings.database.data_directory).is_dir() {
+        info!("Database directory does not exist");
+        return Err(Error::DatabaseDirError);
+    }
+    // Get a database pool
+    let pool = build_pool(
+        "bulk-loader",
+        &settings,
+        OpenFlags::SQLITE_OPEN_READ_WRITE | OpenFlags::SQLITE_OPEN_CREATE,
+        1,
+        4,
+        false,
+    );
+    {
+        // check for database schema version
+        let mut conn: PooledConnection = pool.get()?;
+        let version = curr_db_version(&mut conn)?;
+        info!("current version is: {:?}", version);
+        // ensure the schema version is current.
+        if version != DB_VERSION {
+            info!("version is not current, exiting");
+            panic!("cannot write to schema other than v{DB_VERSION}");
+        }
+    }
+    // this channel will contain parsed events ready to be inserted
+    let (event_tx, event_rx) = mpsc::sync_channel(100_000);
+    // Thread for reading events
+    let _stdin_reader_handler = thread::spawn(move || {
+        let stdin = io::stdin();
+        for readline in stdin.lines() {
+            if let Ok(line) = readline {
+                // try to parse a nostr event
+                let eres: Result<Event, serde_json::Error> = serde_json::from_str(&line);
+                if let Ok(mut e) = eres {
+                    if let Ok(()) = e.validate() {
+                        e.build_index();
+                        //debug!("Event: {:?}", e);
+                        event_tx.send(Some(e)).ok();
+                    } else {
+                        info!("could not validate event");
+                    }
+                } else {
+                    info!("error reading event: {:?}", eres);
+                }
+            } else {
+                // error reading
+                info!("error reading: {:?}", readline);
+            }
+        }
+        info!("finished parsing events");
+        event_tx.send(None).ok();
+        let ok: Result<()> = Ok(());
+        ok
+    });
+    let mut conn: PooledConnection = pool.get()?;
+    let mut events_read = 0;
+    let event_batch_size = 50_000;
+    let mut new_events = 0;
+    let mut has_more_events = true;
+    while has_more_events {
+        // begin a transaction
+        let tx = conn.transaction()?;
+        // read in batch_size events and commit
+        for _ in 0..event_batch_size {
+            match event_rx.recv() {
+                Ok(Some(e)) => {
+                    events_read += 1;
+                    // ignore ephemeral events
+                    if !(e.kind >= 20000 && e.kind < 30000) {
+                        match write_event(&tx, e) {
+                            Ok(c) => {
+                                new_events += c;
+                            }
+                            Err(e) => {
+                                info!("error inserting event: {:?}", e);
+                            }
+                        }
+                    }
+                }
+                Ok(None) => {
+                    // signal that the sender will never produce more
+                    // events
+                    has_more_events = false;
+                    break;
+                }
+                Err(_) => {
+                    info!("sender is closed");
+                    // sender is done
+                }
+            }
+        }
+        info!("committed {} events...", new_events);
+        tx.commit()?;
+        conn.execute_batch("pragma wal_checkpoint(truncate)")?;
+    }
+    info!("processed {} events", events_read);
+    info!("stored {} new events", new_events);
+    // get a connection for writing events
+    // read standard in.
+    info!("finished reading input");
+    Ok(())
+}
+
+/// Write an event and update the tag table.
+/// Assumes the event has its index built.
+fn write_event(tx: &Transaction, e: Event) -> Result<usize> {
+    let id_blob = hex::decode(&e.id).ok();
+    let pubkey_blob: Option<Vec<u8>> = hex::decode(&e.pubkey).ok();
+    let delegator_blob: Option<Vec<u8>> = e.delegated_by.as_ref().and_then(|d| hex::decode(d).ok());
+    let event_str = serde_json::to_string(&e).ok();
+    // ignore if the event hash is a duplicate.
+    let ins_count = tx.execute(
+	"INSERT OR IGNORE INTO event (event_hash, created_at, kind, author, delegated_by, content, first_seen, hidden) VALUES (?1, ?2, ?3, ?4, ?5, ?6, strftime('%s','now'), FALSE);",
+	params![id_blob, e.created_at, e.kind, pubkey_blob, delegator_blob, event_str]
+    )?;
+    if ins_count == 0 {
+        return Ok(0);
+    }
+    // we want to capture the event_id that had the tag, the tag name, and the tag hex value.
+    let event_id = tx.last_insert_rowid();
+    // look at each event, and each tag, creating new tag entries if appropriate.
+    for t in e.tags.iter().filter(|x| x.len() > 1) {
+        let tagname = t.first().unwrap();
+        let tagnamechar_opt = single_char_tagname(tagname);
+        if tagnamechar_opt.is_none() {
+            continue;
+        }
+        // safe because len was > 1
+        let tagval = t.get(1).unwrap();
+        // insert as BLOB if we can restore it losslessly.
+        // this means it needs to be even length and lowercase.
+        if (tagval.len() % 2 == 0) && is_lower_hex(tagval) {
+            tx.execute(
+                "INSERT INTO tag (event_id, name, value_hex) VALUES (?1, ?2, ?3);",
+                params![event_id, tagname, hex::decode(tagval).ok()],
+            )?;
+        } else {
+            // otherwise, insert as text
+            tx.execute(
+                "INSERT INTO tag (event_id, name, value) VALUES (?1, ?2, ?3);",
+                params![event_id, tagname, &tagval],
+            )?;
+        }
+    }
+    if e.is_replaceable() {
+        //let query = "SELECT id FROM event WHERE kind=? AND author=? ORDER BY created_at DESC LIMIT 1;";
+        //let count: usize = tx.query_row(query, params![e.kind, pubkey_blob], |row| row.get(0))?;
+        //info!("found {} rows that /would/ be preserved", count);
+        match tx.execute(
+	    "DELETE FROM event WHERE kind=? and author=? and id NOT IN (SELECT id FROM event WHERE kind=? AND author=? ORDER BY created_at DESC LIMIT 1);",
+	    params![e.kind, pubkey_blob, e.kind, pubkey_blob],
+	) {
+	    Ok(_) => {},
+	    Err(x) => {info!("error deleting replaceable event: {:?}",x);}
+	}
+    }
+    Ok(ins_count)
+}

src/cli.rs

@@ -0,0 +1,20 @@
+use clap::Parser;
+
+#[derive(Parser)]
+#[command(about = "A nostr relay written in Rust", author = env!("CARGO_PKG_AUTHORS"), version = env!("CARGO_PKG_VERSION"))]
+pub struct CLIArgs {
+    #[arg(
+        short,
+        long,
+        help = "Use the <directory> as the location of the database",
+        required = false
+    )]
+    pub db: Option<String>,
+    #[arg(
+        short,
+        long,
+        help = "Use the <file name> as the location of the config file",
+        required = false
+    )]
+    pub config: Option<String>,
+}

src/close.rs

@@ -5,7 +5,7 @@ use crate::error::{Error, Result};
 use serde::{Deserialize, Serialize};
 
 /// Close command in network format
-#[derive(Serialize, Deserialize, PartialEq, Debug, Clone)]
+#[derive(Serialize, Deserialize, PartialEq, Eq, Debug, Clone)]
 pub struct CloseCmd {
     /// Protocol command, expected to always be "CLOSE".
     cmd: String,
@@ -14,7 +14,7 @@ pub struct CloseCmd {
 }
 
 /// Identifier of the subscription to be closed.
-#[derive(Serialize, Deserialize, PartialEq, Debug, Clone)]
+#[derive(Serialize, Deserialize, PartialEq, Eq, Debug, Clone)]
 pub struct Close {
     /// The subscription identifier being closed.
     pub id: String,
@@ -23,10 +23,10 @@ pub struct Close {
 impl From<CloseCmd> for Result<Close> {
     fn from(cc: CloseCmd) -> Result<Close> {
         // ensure command is correct
-        if cc.cmd != "CLOSE" {
-            Err(Error::CommandUnknownError)
-        } else {
+        if cc.cmd == "CLOSE" {
             Ok(Close { id: cc.id })
+        } else {
+            Err(Error::CommandUnknownError)
         }
     }
 }

src/config.rs

@@ -1,16 +1,9 @@
 //! Configuration file and settings management
+use crate::payment::Processor;
 use config::{Config, ConfigError, File};
-use lazy_static::lazy_static;
-use log::*;
 use serde::{Deserialize, Serialize};
-use std::sync::RwLock;
 use std::time::Duration;
 
-// initialize a singleton default configuration
-lazy_static! {
-    pub static ref SETTINGS: RwLock<Settings> = RwLock::new(Settings::default());
-}
-
 #[derive(Debug, Serialize, Deserialize, Clone)]
 #[allow(unused)]
 pub struct Info {
@@ -19,31 +12,46 @@ pub struct Info {
     pub description: Option<String>,
     pub pubkey: Option<String>,
     pub contact: Option<String>,
+    pub favicon: Option<String>,
+    pub relay_icon: Option<String>,
+    pub relay_page: Option<String>,
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 #[allow(unused)]
 pub struct Database {
     pub data_directory: String,
+    pub engine: String,
+    pub in_memory: bool,
     pub min_conn: u32,
     pub max_conn: u32,
+    pub connection: String,
+    pub connection_write: Option<String>,
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[allow(unused)]
+pub struct Grpc {
+    pub event_admission_server: Option<String>,
+    pub restricts_write: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
 #[allow(unused)]
 pub struct Network {
     pub port: u16,
     pub address: String,
+    pub remote_ip_header: Option<String>, // retrieve client IP from this HTTP header if present
+    pub ping_interval_seconds: u32,
 }
 
-//
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 #[allow(unused)]
 pub struct Options {
     pub reject_future_seconds: Option<usize>, // if defined, reject any events with a timestamp more than X seconds in the future
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 #[allow(unused)]
 pub struct Retention {
     // TODO: implement
@@ -53,24 +61,54 @@ pub struct Retention {
     pub whitelist_addresses: Option<Vec<String>>, // whitelisted addresses (never delete)
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 #[allow(unused)]
 pub struct Limits {
     pub messages_per_sec: Option<u32>, // Artificially slow down event writing to limit disk consumption (averaged over 1 minute)
+    pub subscriptions_per_min: Option<u32>, // Artificially slow down request (db query) creation to prevent abuse (averaged over 1 minute)
+    pub db_conns_per_client: Option<u32>, // How many concurrent database queries (not subscriptions) may a client have?
+    pub max_blocking_threads: usize,
     pub max_event_bytes: Option<usize>, // Maximum size of an EVENT message
     pub max_ws_message_bytes: Option<usize>,
     pub max_ws_frame_bytes: Option<usize>,
     pub broadcast_buffer: usize, // events to buffer for subscribers (prevents slow readers from consuming memory)
     pub event_persist_buffer: usize, // events to buffer for database commits (block senders if database writes are too slow)
+    pub event_kind_blacklist: Option<Vec<u64>>,
+    pub event_kind_allowlist: Option<Vec<u64>>,
+    pub limit_scrapers: bool,
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 #[allow(unused)]
 pub struct Authorization {
     pub pubkey_whitelist: Option<Vec<String>>, // If present, only allow these pubkeys to publish events
+    pub nip42_auth: bool,                      // if true enables NIP-42 authentication
+    pub nip42_dms: bool, // if true send DMs only to their authenticated recipients
 }
 
-#[derive(Serialize, Deserialize, PartialEq, Debug, Clone)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[allow(unused)]
+pub struct PayToRelay {
+    pub enabled: bool,
+    pub admission_cost: u64, // Cost to have pubkey whitelisted
+    pub cost_per_event: u64, // Cost author to pay per event
+    pub node_url: String,
+    pub api_secret: String,
+    pub terms_message: String,
+    pub sign_ups: bool,       // allow new users to sign up to relay
+    pub direct_message: bool, // Send direct message to user with invoice and terms
+    pub secret_key: Option<String>,
+    pub processor: Processor,
+    pub rune_path: Option<String>, // To access clightning API
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[allow(unused)]
+pub struct Diagnostics {
+    pub tracing: bool, // enables tokio console-subscriber
+}
+
+#[derive(Serialize, Deserialize, PartialEq, Eq, Debug, Clone, Copy)]
 #[serde(rename_all = "lowercase")]
 pub enum VerifiedUsersMode {
     Enabled,
@@ -78,7 +116,7 @@ pub enum VerifiedUsersMode {
     Disabled,
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 #[allow(unused)]
 pub struct VerifiedUsers {
     pub mode: VerifiedUsersMode, // Mode of operation: "enabled" (enforce) or "passive" (check only). If none, this is simply disabled.
@@ -97,84 +135,142 @@ impl VerifiedUsers {
         self.verify_update_frequency_duration = self.verify_update_duration();
     }
 
+    #[must_use]
     pub fn is_enabled(&self) -> bool {
         self.mode == VerifiedUsersMode::Enabled
     }
 
+    #[must_use]
     pub fn is_active(&self) -> bool {
         self.mode == VerifiedUsersMode::Enabled || self.mode == VerifiedUsersMode::Passive
     }
 
+    #[must_use]
     pub fn is_passive(&self) -> bool {
         self.mode == VerifiedUsersMode::Passive
     }
 
+    #[must_use]
     pub fn verify_expiration_duration(&self) -> Option<Duration> {
         self.verify_expiration
             .as_ref()
             .and_then(|x| parse_duration::parse(x).ok())
     }
+
+    #[must_use]
     pub fn verify_update_duration(&self) -> Option<Duration> {
         self.verify_update_frequency
             .as_ref()
             .and_then(|x| parse_duration::parse(x).ok())
     }
+
+    #[must_use]
     pub fn is_valid(&self) -> bool {
         self.verify_expiration_duration().is_some() && self.verify_update_duration().is_some()
     }
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[allow(unused)]
+pub struct Logging {
+    pub folder_path: Option<String>,
+    pub file_prefix: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
 #[allow(unused)]
 pub struct Settings {
     pub info: Info,
+    pub diagnostics: Diagnostics,
     pub database: Database,
+    pub grpc: Grpc,
     pub network: Network,
     pub limits: Limits,
     pub authorization: Authorization,
+    pub pay_to_relay: PayToRelay,
     pub verified_users: VerifiedUsers,
     pub retention: Retention,
     pub options: Options,
+    pub logging: Logging,
 }
 
 impl Settings {
-    pub fn new() -> Self {
+    pub fn new(config_file_name: &Option<String>) -> Result<Self, ConfigError> {
         let default_settings = Self::default();
         // attempt to construct settings with file
-        let from_file = Self::new_from_default(&default_settings);
+        let from_file = Self::new_from_default(&default_settings, config_file_name);
         match from_file {
-            Ok(f) => f,
             Err(e) => {
-                warn!("Error reading config file ({:?})", e);
-                default_settings
+                // pass up the parse error if the config file was specified,
+                // otherwise use the default config (with a warning).
+                if config_file_name.is_some() {
+                    Err(e)
+                } else {
+                    eprintln!("Error reading config file ({:?})", e);
+                    eprintln!("WARNING: Default configuration settings will be used");
+                    Ok(default_settings)
+                }
             }
+            ok => ok,
         }
     }
 
-    fn new_from_default(default: &Settings) -> Result<Self, ConfigError> {
+    fn new_from_default(
+        default: &Settings,
+        config_file_name: &Option<String>,
+    ) -> Result<Self, ConfigError> {
+        let default_config_file_name = "config.toml".to_string();
+        let config: &String = match config_file_name {
+            Some(value) => value,
+            None => &default_config_file_name,
+        };
         let builder = Config::builder();
         let config: Config = builder
             // use defaults
             .add_source(Config::try_from(default)?)
             // override with file contents
-            .add_source(File::with_name("config"))
-            .build()?
-            .try_into()
-            .unwrap();
+            .add_source(File::with_name(config))
+            .build()?;
         let mut settings: Settings = config.try_deserialize()?;
         // ensure connection pool size is logical
-        if settings.database.min_conn > settings.database.max_conn {
-            panic!(
-                "Database min_conn setting ({}) cannot exceed max_conn ({})",
-                settings.database.min_conn, settings.database.max_conn
-            );
-        }
+        assert!(
+            settings.database.min_conn <= settings.database.max_conn,
+            "Database min_conn setting ({}) cannot exceed max_conn ({})",
+            settings.database.min_conn,
+            settings.database.max_conn
+        );
         // ensure durations parse
-        if !settings.verified_users.is_valid() {
-            panic!("VerifiedUsers time settings could not be parsed");
-        }
+        assert!(
+            settings.verified_users.is_valid(),
+            "VerifiedUsers time settings could not be parsed"
+        );
         // initialize durations for verified users
         settings.verified_users.init();
+
+        // Validate pay to relay settings
+        if settings.pay_to_relay.enabled {
+            if settings.pay_to_relay.processor == Processor::ClnRest {
+                assert!(settings
+                    .pay_to_relay
+                    .rune_path
+                    .as_ref()
+                    .is_some_and(|path| path != "<rune path>"));
+            } else if settings.pay_to_relay.processor == Processor::LNBits {
+                assert_ne!(settings.pay_to_relay.api_secret, "");
+            }
+            // Should check that url is valid
+            assert_ne!(settings.pay_to_relay.node_url, "");
+            assert_ne!(settings.pay_to_relay.terms_message, "");
+
+            if settings.pay_to_relay.direct_message {
+                assert!(settings
+                    .pay_to_relay
+                    .secret_key
+                    .as_ref()
+                    .is_some_and(|key| key != "<nostr nsec>"));
+            }
+        }
+
         Ok(settings)
     }
 }
@@ -188,26 +284,61 @@ impl Default for Settings {
                 description: None,
                 pubkey: None,
                 contact: None,
+                favicon: None,
+                relay_icon: None,
+                relay_page: None,
             },
+            diagnostics: Diagnostics { tracing: false },
             database: Database {
                 data_directory: ".".to_owned(),
+                engine: "sqlite".to_owned(),
+                in_memory: false,
                 min_conn: 4,
-                max_conn: 128,
+                max_conn: 8,
+                connection: "".to_owned(),
+                connection_write: None,
+            },
+            grpc: Grpc {
+                event_admission_server: None,
+                restricts_write: false,
             },
             network: Network {
                 port: 8080,
+                ping_interval_seconds: 300,
                 address: "0.0.0.0".to_owned(),
+                remote_ip_header: None,
             },
             limits: Limits {
                 messages_per_sec: None,
+                subscriptions_per_min: None,
+                db_conns_per_client: None,
+                max_blocking_threads: 16,
                 max_event_bytes: Some(2 << 17),      // 128K
                 max_ws_message_bytes: Some(2 << 17), // 128K
                 max_ws_frame_bytes: Some(2 << 17),   // 128K
                 broadcast_buffer: 16384,
                 event_persist_buffer: 4096,
+                event_kind_blacklist: None,
+                event_kind_allowlist: None,
+                limit_scrapers: false,
             },
             authorization: Authorization {
                 pubkey_whitelist: None, // Allow any address to publish
+                nip42_auth: false,      // Disable NIP-42 authentication
+                nip42_dms: false,       // Send DMs to everybody
+            },
+            pay_to_relay: PayToRelay {
+                enabled: false,
+                admission_cost: 4200,
+                cost_per_event: 0,
+                terms_message: "".to_string(),
+                node_url: "".to_string(),
+                api_secret: "".to_string(),
+                rune_path: None,
+                sign_ups: false,
+                direct_message: false,
+                secret_key: None,
+                processor: Processor::LNBits,
             },
             verified_users: VerifiedUsers {
                 mode: VerifiedUsersMode::Disabled,
@@ -226,7 +357,11 @@ impl Default for Settings {
                 whitelist_addresses: None, // whitelisted addresses (never delete)
             },
             options: Options {
-                reject_future_seconds: Some(30 * 60), // Reject events 30min in the future or greater
+                reject_future_seconds: None, // Reject events in the future if defined
+            },
+            logging: Logging {
+                folder_path: None,
+                file_prefix: None,
             },
         }
     }

src/conn.rs

@@ -1,69 +1,115 @@
 //! Client connection state
+use std::collections::HashMap;
+
+use tracing::{debug, trace};
+use uuid::Uuid;
+
 use crate::close::Close;
+use crate::conn::Nip42AuthState::{AuthPubkey, Challenge, NoAuth};
 use crate::error::Error;
 use crate::error::Result;
 use crate::event::Event;
-
 use crate::subscription::Subscription;
-use log::*;
-use std::collections::HashMap;
-use uuid::Uuid;
+use crate::utils::{host_str, unix_time};
 
 /// A subscription identifier has a maximum length
 const MAX_SUBSCRIPTION_ID_LEN: usize = 256;
 
+/// NIP-42 authentication state
+pub enum Nip42AuthState {
+    /// The client is not authenticated yet
+    NoAuth,
+    /// The AUTH challenge sent
+    Challenge(String),
+    /// The client is authenticated
+    AuthPubkey(String),
+}
+
 /// State for a client connection
 pub struct ClientConn {
+    /// Client IP (either from socket, or configured proxy header
+    client_ip_addr: String,
     /// Unique client identifier generated at connection time
     client_id: Uuid,
     /// The current set of active client subscriptions
     subscriptions: HashMap<String, Subscription>,
     /// Per-connection maximum concurrent subscriptions
     max_subs: usize,
+    /// NIP-42 AUTH
+    auth: Nip42AuthState,
 }
 
 impl Default for ClientConn {
     fn default() -> Self {
-        Self::new()
+        Self::new("unknown".to_owned())
     }
 }
 
 impl ClientConn {
     /// Create a new, empty connection state.
-    pub fn new() -> Self {
+    #[must_use]
+    pub fn new(client_ip_addr: String) -> Self {
         let client_id = Uuid::new_v4();
         ClientConn {
+            client_ip_addr,
             client_id,
             subscriptions: HashMap::new(),
             max_subs: 32,
+            auth: NoAuth,
         }
     }
 
+    #[must_use]
+    pub fn subscriptions(&self) -> &HashMap<String, Subscription> {
+        &self.subscriptions
+    }
+
+    /// Check if the given subscription already exists
+    #[must_use]
+    pub fn has_subscription(&self, sub: &Subscription) -> bool {
+        self.subscriptions.values().any(|x| x == sub)
+    }
+
     /// Get a short prefix of the client's unique identifier, suitable
     /// for logging.
+    #[must_use]
     pub fn get_client_prefix(&self) -> String {
         self.client_id.to_string().chars().take(8).collect()
     }
 
-    /// Find all matching subscriptions.
-    pub fn get_matching_subscriptions(&self, e: &Event) -> Vec<&str> {
-        let mut v: Vec<&str> = vec![];
-        for (id, sub) in self.subscriptions.iter() {
-            if sub.interested_in_event(e) {
-                v.push(id);
-            }
+    #[must_use]
+    pub fn ip(&self) -> &str {
+        &self.client_ip_addr
+    }
+
+    #[must_use]
+    pub fn auth_pubkey(&self) -> Option<&String> {
+        match &self.auth {
+            AuthPubkey(pubkey) => Some(pubkey),
+            _ => None,
+        }
+    }
+
+    #[must_use]
+    pub fn auth_challenge(&self) -> Option<&String> {
+        match &self.auth {
+            Challenge(pubkey) => Some(pubkey),
+            _ => None,
         }
-        v
     }
 
     /// Add a new subscription for this connection.
+    /// # Errors
+    ///
+    /// Will return `Err` if the client has too many subscriptions, or
+    /// if the provided name is excessively long.
     pub fn subscribe(&mut self, s: Subscription) -> Result<()> {
         let k = s.get_id();
         let sub_id_len = k.len();
         // prevent arbitrarily long subscription identifiers from
         // being used.
         if sub_id_len > MAX_SUBSCRIPTION_ID_LEN {
-            info!(
+            debug!(
                 "ignoring sub request with excessive length: ({})",
                 sub_id_len
             );
@@ -72,8 +118,12 @@ impl ClientConn {
         // check if an existing subscription exists, and replace if so
         if self.subscriptions.contains_key(&k) {
             self.subscriptions.remove(&k);
-            self.subscriptions.insert(k, s);
-            debug!("replaced existing subscription");
+            self.subscriptions.insert(k, s.clone());
+            trace!(
+                "replaced existing subscription (cid: {}, sub: {:?})",
+                self.get_client_prefix(),
+                s.get_id()
+            );
             return Ok(());
         }
 
@@ -83,20 +133,97 @@ impl ClientConn {
         }
         // add subscription
         self.subscriptions.insert(k, s);
-        debug!(
-            "registered new subscription, currently have {} active subs",
-            self.subscriptions.len()
+        trace!(
+            "registered new subscription, currently have {} active subs (cid: {})",
+            self.subscriptions.len(),
+            self.get_client_prefix(),
         );
         Ok(())
     }
 
     /// Remove the subscription for this connection.
-    pub fn unsubscribe(&mut self, c: Close) {
+    pub fn unsubscribe(&mut self, c: &Close) {
         // TODO: return notice if subscription did not exist.
         self.subscriptions.remove(&c.id);
-        debug!(
-            "removed subscription, currently have {} active subs",
-            self.subscriptions.len()
+        trace!(
+            "removed subscription, currently have {} active subs (cid: {})",
+            self.subscriptions.len(),
+            self.get_client_prefix(),
         );
     }
+
+    pub fn generate_auth_challenge(&mut self) {
+        self.auth = Challenge(Uuid::new_v4().to_string());
+    }
+
+    pub fn authenticate(&mut self, event: &Event, relay_url: &str) -> Result<()> {
+        match &self.auth {
+            Challenge(_) => (),
+            AuthPubkey(_) => {
+                // already authenticated
+                return Ok(());
+            }
+            NoAuth => {
+                // unexpected AUTH request
+                return Err(Error::AuthFailure);
+            }
+        }
+        match event.validate() {
+            Ok(_) => {
+                if event.kind != 22242 {
+                    return Err(Error::AuthFailure);
+                }
+
+                let curr_time = unix_time();
+                let past_cutoff = curr_time - 600; // 10 minutes
+                let future_cutoff = curr_time + 600; // 10 minutes
+                if event.created_at < past_cutoff || event.created_at > future_cutoff {
+                    return Err(Error::AuthFailure);
+                }
+
+                let mut challenge: Option<&str> = None;
+                let mut relay: Option<&str> = None;
+
+                for tag in &event.tags {
+                    if tag.len() == 2 && tag.first() == Some(&"challenge".into()) {
+                        challenge = tag.get(1).map(|x| x.as_str());
+                    }
+                    if tag.len() == 2 && tag.first() == Some(&"relay".into()) {
+                        relay = tag.get(1).map(|x| x.as_str());
+                    }
+                }
+
+                match (challenge, &self.auth) {
+                    (Some(received_challenge), Challenge(sent_challenge)) => {
+                        if received_challenge != sent_challenge {
+                            return Err(Error::AuthFailure);
+                        }
+                    }
+                    (_, _) => {
+                        return Err(Error::AuthFailure);
+                    }
+                }
+
+                match (relay.and_then(host_str), host_str(relay_url)) {
+                    (Some(received_relay), Some(our_relay)) => {
+                        if received_relay != our_relay {
+                            return Err(Error::AuthFailure);
+                        }
+                    }
+                    (_, _) => {
+                        return Err(Error::AuthFailure);
+                    }
+                }
+
+                self.auth = AuthPubkey(event.pubkey.clone());
+                trace!(
+                    "authenticated pubkey {} (cid: {})",
+                    event.pubkey.chars().take(8).collect::<String>(),
+                    self.get_client_prefix()
+                );
+                Ok(())
+            }
+            Err(_) => Err(Error::AuthFailure),
+        }
+    }
 }

src/delegation.rs

@@ -0,0 +1,406 @@
+//! Event parsing and validation
+use crate::error::Error;
+use crate::error::Result;
+use crate::event::Event;
+use bitcoin_hashes::{sha256, Hash};
+use lazy_static::lazy_static;
+use regex::Regex;
+use secp256k1::{schnorr, Secp256k1, VerifyOnly, XOnlyPublicKey};
+use serde::{Deserialize, Serialize};
+use std::str::FromStr;
+use tracing::{debug, info};
+
+// This handles everything related to delegation, in particular the
+// condition/rune parsing and logic.
+
+// Conditions are poorly specified, so we will implement the minimum
+// necessary for now.
+
+// fields MUST be either "kind" or "created_at".
+// operators supported are ">", "<", "=", "!".
+// no operations on 'content' are supported.
+
+// this allows constraints for:
+// valid date ranges (valid from X->Y dates).
+// specific kinds (publish kind=1,5)
+// kind ranges (publish ephemeral events, kind>19999&kind<30001)
+
+// for more complex scenarios (allow delegatee to publish ephemeral
+// AND replacement events), it may be necessary to generate and use
+// different condition strings, since we do not support grouping or
+// "OR" logic.
+
+lazy_static! {
+    /// Secp256k1 verification instance.
+    pub static ref SECP: Secp256k1<VerifyOnly> = Secp256k1::verification_only();
+}
+
+#[derive(Serialize, Deserialize, PartialEq, Eq, Debug, Clone)]
+pub enum Field {
+    Kind,
+    CreatedAt,
+}
+
+impl FromStr for Field {
+    type Err = Error;
+    fn from_str(value: &str) -> Result<Self, Self::Err> {
+        if value == "kind" {
+            Ok(Field::Kind)
+        } else if value == "created_at" {
+            Ok(Field::CreatedAt)
+        } else {
+            Err(Error::DelegationParseError)
+        }
+    }
+}
+
+#[derive(Serialize, Deserialize, PartialEq, Eq, Debug, Clone)]
+pub enum Operator {
+    LessThan,
+    GreaterThan,
+    Equals,
+    NotEquals,
+}
+impl FromStr for Operator {
+    type Err = Error;
+    fn from_str(value: &str) -> Result<Self, Self::Err> {
+        if value == "<" {
+            Ok(Operator::LessThan)
+        } else if value == ">" {
+            Ok(Operator::GreaterThan)
+        } else if value == "=" {
+            Ok(Operator::Equals)
+        } else if value == "!" {
+            Ok(Operator::NotEquals)
+        } else {
+            Err(Error::DelegationParseError)
+        }
+    }
+}
+
+#[derive(Serialize, Deserialize, PartialEq, Eq, Debug, Clone)]
+pub struct ConditionQuery {
+    pub conditions: Vec<Condition>,
+}
+
+impl ConditionQuery {
+    #[must_use]
+    pub fn allows_event(&self, event: &Event) -> bool {
+        // check each condition, to ensure that the event complies
+        // with the restriction.
+        for c in &self.conditions {
+            if !c.allows_event(event) {
+                // any failing conditions invalidates the delegation
+                // on this event
+                return false;
+            }
+        }
+        // delegation was permitted unconditionally, or all conditions
+        // were true
+        true
+    }
+}
+
+// Verify that the delegator approved the delegation; return a ConditionQuery if so.
+#[must_use]
+pub fn validate_delegation(
+    delegator: &str,
+    delegatee: &str,
+    cond_query: &str,
+    sigstr: &str,
+) -> Option<ConditionQuery> {
+    // form the token
+    let tok = format!("nostr:delegation:{delegatee}:{cond_query}");
+    // form SHA256 hash
+    let digest: sha256::Hash = sha256::Hash::hash(tok.as_bytes());
+    let sig = schnorr::Signature::from_str(sigstr).unwrap();
+    if let Ok(msg) = secp256k1::Message::from_slice(digest.as_ref()) {
+        if let Ok(pubkey) = XOnlyPublicKey::from_str(delegator) {
+            let verify = SECP.verify_schnorr(&sig, &msg, &pubkey);
+            if verify.is_ok() {
+                // return the parsed condition query
+                cond_query.parse::<ConditionQuery>().ok()
+            } else {
+                debug!("client sent an delegation signature that did not validate");
+                None
+            }
+        } else {
+            debug!("client sent malformed delegation pubkey");
+            None
+        }
+    } else {
+        info!("error converting delegation digest to secp256k1 message");
+        None
+    }
+}
+
+/// Parsed delegation condition
+/// see <https://github.com/nostr-protocol/nips/pull/28#pullrequestreview-1084903800>
+/// An example complex condition would be:  `kind=1,2,3&created_at<1665265999`
+#[derive(Serialize, Deserialize, PartialEq, Eq, Debug, Clone)]
+pub struct Condition {
+    pub field: Field,
+    pub operator: Operator,
+    pub values: Vec<u64>,
+}
+
+impl Condition {
+    /// Check if this condition allows the given event to be delegated
+    #[must_use]
+    pub fn allows_event(&self, event: &Event) -> bool {
+        // determine what the right-hand side of the operator is
+        let resolved_field = match &self.field {
+            Field::Kind => event.kind,
+            Field::CreatedAt => event.created_at,
+        };
+        match &self.operator {
+            Operator::LessThan => {
+                // the less-than operator is only valid for single values.
+                if self.values.len() == 1 {
+                    if let Some(v) = self.values.first() {
+                        return resolved_field < *v;
+                    }
+                }
+            }
+            Operator::GreaterThan => {
+                // the greater-than operator is only valid for single values.
+                if self.values.len() == 1 {
+                    if let Some(v) = self.values.first() {
+                        return resolved_field > *v;
+                    }
+                }
+            }
+            Operator::Equals => {
+                // equals is interpreted as "must be equal to at least one provided value"
+                return self.values.iter().any(|&x| resolved_field == x);
+            }
+            Operator::NotEquals => {
+                // not-equals is interpreted as "must not be equal to any provided value"
+                // this is the one case where an empty list of values could be allowed; even though it is a pointless restriction.
+                return self.values.iter().all(|&x| resolved_field != x);
+            }
+        }
+        false
+    }
+}
+
+fn str_to_condition(cs: &str) -> Option<Condition> {
+    // a condition is a string (alphanum+underscore), an operator (<>=!), and values (num+comma)
+    lazy_static! {
+        static ref RE: Regex = Regex::new("([[:word:]]+)([<>=!]+)([,[[:digit:]]]*)").unwrap();
+    }
+    // match against the regex
+    let caps = RE.captures(cs)?;
+    let field = caps.get(1)?.as_str().parse::<Field>().ok()?;
+    let operator = caps.get(2)?.as_str().parse::<Operator>().ok()?;
+    // values are just comma separated numbers, but all must be parsed
+    let rawvals = caps.get(3)?.as_str();
+    let values = rawvals
+        .split_terminator(',')
+        .map(|n| n.parse::<u64>().ok())
+        .collect::<Option<Vec<_>>>()?;
+    // convert field string into Field
+    Some(Condition {
+        field,
+        operator,
+        values,
+    })
+}
+
+/// Parse a condition query from a string slice
+impl FromStr for ConditionQuery {
+    type Err = Error;
+    fn from_str(value: &str) -> Result<Self, Self::Err> {
+        // split the string with '&'
+        let mut conditions = vec![];
+        let condstrs = value.split_terminator('&');
+        // parse each individual condition
+        for c in condstrs {
+            conditions.push(str_to_condition(c).ok_or(Error::DelegationParseError)?);
+        }
+        Ok(ConditionQuery { conditions })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // parse condition strings
+    #[test]
+    fn parse_empty() -> Result<()> {
+        // given an empty condition query, produce an empty vector
+        let empty_cq = ConditionQuery { conditions: vec![] };
+        let parsed = "".parse::<ConditionQuery>()?;
+        assert_eq!(parsed, empty_cq);
+        Ok(())
+    }
+
+    // parse field 'kind'
+    #[test]
+    fn test_kind_field_parse() -> Result<()> {
+        let field = "kind".parse::<Field>()?;
+        assert_eq!(field, Field::Kind);
+        Ok(())
+    }
+    // parse field 'created_at'
+    #[test]
+    fn test_created_at_field_parse() -> Result<()> {
+        let field = "created_at".parse::<Field>()?;
+        assert_eq!(field, Field::CreatedAt);
+        Ok(())
+    }
+    // parse unknown field
+    #[test]
+    fn unknown_field_parse() {
+        let field = "unk".parse::<Field>();
+        assert!(field.is_err());
+    }
+
+    // parse a full conditional query with an empty array
+    #[test]
+    fn parse_kind_equals_empty() -> Result<()> {
+        // given an empty condition query, produce an empty vector
+        let kind_cq = ConditionQuery {
+            conditions: vec![Condition {
+                field: Field::Kind,
+                operator: Operator::Equals,
+                values: vec![],
+            }],
+        };
+        let parsed = "kind=".parse::<ConditionQuery>()?;
+        assert_eq!(parsed, kind_cq);
+        Ok(())
+    }
+    // parse a full conditional query with a single value
+    #[test]
+    fn parse_kind_equals_singleval() -> Result<()> {
+        // given an empty condition query, produce an empty vector
+        let kind_cq = ConditionQuery {
+            conditions: vec![Condition {
+                field: Field::Kind,
+                operator: Operator::Equals,
+                values: vec![1],
+            }],
+        };
+        let parsed = "kind=1".parse::<ConditionQuery>()?;
+        assert_eq!(parsed, kind_cq);
+        Ok(())
+    }
+    // parse a full conditional query with multiple values
+    #[test]
+    fn parse_kind_equals_multival() -> Result<()> {
+        // given an empty condition query, produce an empty vector
+        let kind_cq = ConditionQuery {
+            conditions: vec![Condition {
+                field: Field::Kind,
+                operator: Operator::Equals,
+                values: vec![1, 2, 4],
+            }],
+        };
+        let parsed = "kind=1,2,4".parse::<ConditionQuery>()?;
+        assert_eq!(parsed, kind_cq);
+        Ok(())
+    }
+    // parse multiple conditions
+    #[test]
+    fn parse_multi_conditions() -> Result<()> {
+        // given an empty condition query, produce an empty vector
+        let cq = ConditionQuery {
+            conditions: vec![
+                Condition {
+                    field: Field::Kind,
+                    operator: Operator::GreaterThan,
+                    values: vec![10000],
+                },
+                Condition {
+                    field: Field::Kind,
+                    operator: Operator::LessThan,
+                    values: vec![20000],
+                },
+                Condition {
+                    field: Field::Kind,
+                    operator: Operator::NotEquals,
+                    values: vec![10001],
+                },
+                Condition {
+                    field: Field::CreatedAt,
+                    operator: Operator::LessThan,
+                    values: vec![1_665_867_123],
+                },
+            ],
+        };
+        let parsed =
+            "kind>10000&kind<20000&kind!10001&created_at<1665867123".parse::<ConditionQuery>()?;
+        assert_eq!(parsed, cq);
+        Ok(())
+    }
+    // Check for condition logic on event w/ empty values
+    #[test]
+    fn condition_with_empty_values() {
+        let mut c = Condition {
+            field: Field::Kind,
+            operator: Operator::GreaterThan,
+            values: vec![],
+        };
+        let e = Event::simple_event();
+        assert!(!c.allows_event(&e));
+        c.operator = Operator::LessThan;
+        assert!(!c.allows_event(&e));
+        c.operator = Operator::Equals;
+        assert!(!c.allows_event(&e));
+        // Not Equals applied to an empty list *is* allowed
+        // (pointless, but logically valid).
+        c.operator = Operator::NotEquals;
+        assert!(c.allows_event(&e));
+    }
+
+    // Check for condition logic on event w/ single value
+    #[test]
+    fn condition_kind_gt_event_single() {
+        let c = Condition {
+            field: Field::Kind,
+            operator: Operator::GreaterThan,
+            values: vec![10],
+        };
+        let mut e = Event::simple_event();
+        // kind is not greater than 10, not allowed
+        e.kind = 1;
+        assert!(!c.allows_event(&e));
+        // kind is greater than 10, allowed
+        e.kind = 100;
+        assert!(c.allows_event(&e));
+        // kind is 10, not allowed
+        e.kind = 10;
+        assert!(!c.allows_event(&e));
+    }
+    // Check for condition logic on event w/ multi values
+    #[test]
+    fn condition_with_multi_values() {
+        let mut c = Condition {
+            field: Field::Kind,
+            operator: Operator::Equals,
+            values: vec![0, 10, 20],
+        };
+        let mut e = Event::simple_event();
+        // Allow if event kind is in list for Equals
+        e.kind = 10;
+        assert!(c.allows_event(&e));
+        // Deny if event kind is not in list for Equals
+        e.kind = 11;
+        assert!(!c.allows_event(&e));
+        // Deny if event kind is in list for NotEquals
+        e.kind = 10;
+        c.operator = Operator::NotEquals;
+        assert!(!c.allows_event(&e));
+        // Allow if event kind is not in list for NotEquals
+        e.kind = 99;
+        c.operator = Operator::NotEquals;
+        assert!(c.allows_event(&e));
+        // Always deny if GreaterThan/LessThan for a list
+        c.operator = Operator::LessThan;
+        assert!(!c.allows_event(&e));
+        c.operator = Operator::GreaterThan;
+        assert!(!c.allows_event(&e));
+    }
+}

src/error.rs

@@ -17,10 +17,16 @@ pub enum Error {
     ConnWriteError,
     #[error("EVENT parse failed")]
     EventParseFailed,
-    #[error("ClOSE message parse failed")]
+    #[error("CLOSE message parse failed")]
     CloseParseFailed,
-    #[error("Event validation failed")]
-    EventInvalid,
+    #[error("Event invalid signature")]
+    EventInvalidSignature,
+    #[error("Event invalid id")]
+    EventInvalidId,
+    #[error("Event malformed pubkey")]
+    EventMalformedPubkey,
+    #[error("Event could not canonicalize")]
+    EventCouldNotCanonicalize,
     #[error("Event too large")]
     EventMaxLengthError(usize),
     #[error("Subscription identifier max length exceeded")]
@@ -36,12 +42,16 @@ pub enum Error {
     CommandUnknownError,
     #[error("SQL error")]
     SqlError(rusqlite::Error),
-    #[error("Config error")]
+    #[error("Config error : {0}")]
     ConfigError(config::ConfigError),
     #[error("Data directory does not exist")]
     DatabaseDirError,
     #[error("Database Connection Pool Error")]
     DatabasePoolError(r2d2::Error),
+    #[error("SQL error")]
+    SqlxError(sqlx::Error),
+    #[error("Database Connection Pool Error")]
+    SqlxDatabasePoolError(sqlx::Error),
     #[error("Custom Error : {0}")]
     CustomError(String),
     #[error("Task join error")]
@@ -50,6 +60,28 @@ pub enum Error {
     HyperError(hyper::Error),
     #[error("Hex encoding error")]
     HexError(hex::FromHexError),
+    #[error("Delegation parse error")]
+    DelegationParseError,
+    #[error("Channel closed error")]
+    ChannelClosed,
+    #[error("Authz error")]
+    AuthzError,
+    #[error("Tonic GRPC error")]
+    TonicError(tonic::Status),
+    #[error("Invalid AUTH message")]
+    AuthFailure,
+    #[error("I/O Error")]
+    IoError(std::io::Error),
+    #[error("Event builder error")]
+    EventError(nostr::event::builder::Error),
+    #[error("Nostr key error")]
+    NostrKeyError(nostr::key::Error),
+    #[error("Payment hash mismatch")]
+    PaymentHash,
+    #[error("Error parsing url")]
+    URLParseError(url::ParseError),
+    #[error("HTTP error")]
+    HTTPError(http::Error),
     #[error("Unknown/Undocumented")]
     UnknownError,
 }
@@ -92,6 +124,12 @@ impl From<rusqlite::Error> for Error {
     }
 }
 
+impl From<sqlx::Error> for Error {
+    fn from(d: sqlx::Error) -> Self {
+        Error::SqlxDatabasePoolError(d)
+    }
+}
+
 impl From<serde_json::Error> for Error {
     /// Wrap JSON error
     fn from(r: serde_json::Error) -> Self {
@@ -112,3 +150,43 @@ impl From<config::ConfigError> for Error {
         Error::ConfigError(r)
     }
 }
+
+impl From<tonic::Status> for Error {
+    /// Wrap Config error
+    fn from(r: tonic::Status) -> Self {
+        Error::TonicError(r)
+    }
+}
+
+impl From<std::io::Error> for Error {
+    fn from(r: std::io::Error) -> Self {
+        Error::IoError(r)
+    }
+}
+impl From<nostr::event::builder::Error> for Error {
+    /// Wrap event builder error
+    fn from(r: nostr::event::builder::Error) -> Self {
+        Error::EventError(r)
+    }
+}
+
+impl From<nostr::key::Error> for Error {
+    /// Wrap nostr key error
+    fn from(r: nostr::key::Error) -> Self {
+        Error::NostrKeyError(r)
+    }
+}
+
+impl From<url::ParseError> for Error {
+    /// Wrap nostr key error
+    fn from(r: url::ParseError) -> Self {
+        Error::URLParseError(r)
+    }
+}
+
+impl From<http::Error> for Error {
+    /// Wrap nostr key error
+    fn from(r: http::Error) -> Self {
+        Error::HTTPError(r)
+    }
+}

src/event.rs

@@ -1,12 +1,16 @@
 //! Event parsing and validation
-use crate::config;
-use crate::error::Error::*;
+use crate::delegation::validate_delegation;
+use crate::error::Error::{
+    CommandUnknownError, EventCouldNotCanonicalize, EventInvalidId, EventInvalidSignature,
+    EventMalformedPubkey,
+};
 use crate::error::Result;
+use crate::event::EventWrapper::WrappedAuth;
+use crate::event::EventWrapper::WrappedEvent;
 use crate::nip05;
 use crate::utils::unix_time;
 use bitcoin_hashes::{sha256, Hash};
 use lazy_static::lazy_static;
-use log::*;
 use secp256k1::{schnorr, Secp256k1, VerifyOnly, XOnlyPublicKey};
 use serde::{Deserialize, Deserializer, Serialize};
 use serde_json::value::Value;
@@ -14,6 +18,7 @@ use serde_json::Number;
 use std::collections::HashMap;
 use std::collections::HashSet;
 use std::str::FromStr;
+use tracing::{debug, info};
 
 lazy_static! {
     /// Secp256k1 verification instance.
@@ -21,27 +26,36 @@ lazy_static! {
 }
 
 /// Event command in network format.
-#[derive(Serialize, Deserialize, PartialEq, Debug, Clone)]
+#[derive(Serialize, Deserialize, PartialEq, Eq, Debug, Clone)]
 pub struct EventCmd {
     cmd: String, // expecting static "EVENT"
     event: Event,
 }
 
+impl EventCmd {
+    #[must_use]
+    pub fn event_id(&self) -> &str {
+        &self.event.id
+    }
+}
+
 /// Parsed nostr event.
-#[derive(Serialize, Deserialize, PartialEq, Debug, Clone)]
+#[derive(Serialize, Deserialize, PartialEq, Eq, Debug, Clone)]
 pub struct Event {
     pub id: String,
-    pub(crate) pubkey: String,
-    pub(crate) created_at: u64,
-    pub(crate) kind: u64,
+    pub pubkey: String,
+    #[serde(skip)]
+    pub delegated_by: Option<String>,
+    pub created_at: u64,
+    pub kind: u64,
     #[serde(deserialize_with = "tag_from_string")]
     // NOTE: array-of-arrays may need to be more general than a string container
-    pub(crate) tags: Vec<Vec<String>>,
-    pub(crate) content: String,
-    pub(crate) sig: String,
+    pub tags: Vec<Vec<String>>,
+    pub content: String,
+    pub sig: String,
     // Optimization for tag search, built on demand.
     #[serde(skip)]
-    pub(crate) tagidx: Option<HashMap<char, HashSet<String>>>,
+    pub tagidx: Option<HashMap<char, HashSet<String>>>,
 }
 
 /// Simple tag type for array of array of strings.
@@ -53,16 +67,17 @@ where
     D: Deserializer<'de>,
 {
     let opt = Option::deserialize(deserializer)?;
-    Ok(opt.unwrap_or_else(Vec::new))
+    Ok(opt.unwrap_or_default())
 }
 
 /// Attempt to form a single-char tag name.
+#[must_use]
 pub fn single_char_tagname(tagname: &str) -> Option<char> {
     // We return the tag character if and only if the tagname consists
     // of a single char.
     let mut tagnamechars = tagname.chars();
     let firstchar = tagnamechars.next();
-    return match firstchar {
+    match firstchar {
         Some(_) => {
             // check second char
             if tagnamechars.next().is_none() {
@@ -72,31 +87,127 @@ pub fn single_char_tagname(tagname: &str) -> Option<char> {
             }
         }
         None => None,
-    };
+    }
+}
+
+pub enum EventWrapper {
+    WrappedEvent(Event),
+    WrappedAuth(Event),
 }
 
 /// Convert network event to parsed/validated event.
-impl From<EventCmd> for Result<Event> {
-    fn from(ec: EventCmd) -> Result<Event> {
+impl From<EventCmd> for Result<EventWrapper> {
+    fn from(ec: EventCmd) -> Result<EventWrapper> {
         // ensure command is correct
-        if ec.cmd != "EVENT" {
-            Err(CommandUnknownError)
-        } else if ec.event.is_valid() {
-            let mut e = ec.event;
-            e.build_index();
-            Ok(e)
+        if ec.cmd == "EVENT" {
+            ec.event.validate().map(|_| {
+                let mut e = ec.event;
+                e.build_index();
+                e.update_delegation();
+                WrappedEvent(e)
+            })
+        } else if ec.cmd == "AUTH" {
+            // we don't want to validate the event here, because NIP-42 can be disabled
+            // it will be validated later during the authentication process
+            Ok(WrappedAuth(ec.event))
         } else {
-            Err(EventInvalid)
+            Err(CommandUnknownError)
         }
     }
 }
 
 impl Event {
+    #[cfg(test)]
+    #[must_use]
+    pub fn simple_event() -> Event {
+        Event {
+            id: "0".to_owned(),
+            pubkey: "0".to_owned(),
+            delegated_by: None,
+            created_at: 0,
+            kind: 0,
+            tags: vec![],
+            content: "".to_owned(),
+            sig: "0".to_owned(),
+            tagidx: None,
+        }
+    }
+
+    #[must_use]
     pub fn is_kind_metadata(&self) -> bool {
         self.kind == 0
     }
 
+    /// Should this event be persisted?
+    #[must_use]
+    pub fn is_ephemeral(&self) -> bool {
+        self.kind >= 20000 && self.kind < 30000
+    }
+
+    /// Is this event currently expired?
+    pub fn is_expired(&self) -> bool {
+        if let Some(exp) = self.expiration() {
+            exp <= unix_time()
+        } else {
+            false
+        }
+    }
+
+    /// Determine the time at which this event should expire
+    pub fn expiration(&self) -> Option<u64> {
+        let default = "".to_string();
+        let dvals: Vec<&String> = self
+            .tags
+            .iter()
+            .filter(|x| !x.is_empty())
+            .filter(|x| x.first().unwrap() == "expiration")
+            .map(|x| x.get(1).unwrap_or(&default))
+            .take(1)
+            .collect();
+        let val_first = dvals.first();
+        val_first.and_then(|t| t.parse::<u64>().ok())
+    }
+
+    /// Should this event be replaced with newer timestamps from same author?
+    #[must_use]
+    pub fn is_replaceable(&self) -> bool {
+        self.kind == 0
+            || self.kind == 3
+            || self.kind == 41
+            || (self.kind >= 10000 && self.kind < 20000)
+    }
+
+    /// Should this event be replaced with newer timestamps from same author, for distinct `d` tag values?
+    #[must_use]
+    pub fn is_param_replaceable(&self) -> bool {
+        self.kind >= 30000 && self.kind < 40000
+    }
+
+    /// Should this event be replaced with newer timestamps from same author, for distinct `d` tag values?
+    #[must_use]
+    pub fn distinct_param(&self) -> Option<String> {
+        if self.is_param_replaceable() {
+            let default = "".to_string();
+            let dvals: Vec<&String> = self
+                .tags
+                .iter()
+                .filter(|x| !x.is_empty())
+                .filter(|x| x.first().unwrap() == "d")
+                .map(|x| x.get(1).unwrap_or(&default))
+                .take(1)
+                .collect();
+            let dval_first = dvals.first();
+            match dval_first {
+                Some(_) => dval_first.map(|x| x.to_string()),
+                None => Some(default),
+            }
+        } else {
+            None
+        }
+    }
+
     /// Pull a NIP-05 Name out of the event, if one exists
+    #[must_use]
     pub fn get_nip05_addr(&self) -> Option<nip05::Nip05Name> {
         if self.is_kind_metadata() {
             // very quick check if we should attempt to parse this json
@@ -111,8 +222,53 @@ impl Event {
         None
     }
 
+    // is this event delegated (properly)?
+    // does the signature match, and are conditions valid?
+    // if so, return an alternate author for the event
+    #[must_use]
+    pub fn delegated_author(&self) -> Option<String> {
+        // is there a delegation tag?
+        let delegation_tag: Vec<String> = self
+            .tags
+            .iter()
+            .filter(|x| x.len() == 4)
+            .filter(|x| x.first().unwrap() == "delegation")
+            .take(1)
+            .next()?
+            .clone(); // get first tag
+
+        //let delegation_tag = self.tag_values_by_name("delegation");
+        // delegation tags should have exactly 3 elements after the name (pubkey, condition, sig)
+        // the event is signed by the delagatee
+        let delegatee = &self.pubkey;
+        // the delegation tag references the claimed delagator
+        let delegator: &str = delegation_tag.get(1)?;
+        let querystr: &str = delegation_tag.get(2)?;
+        let sig: &str = delegation_tag.get(3)?;
+
+        // attempt to get a condition query; this requires the delegation to have a valid signature.
+        if let Some(cond_query) = validate_delegation(delegator, delegatee, querystr, sig) {
+            // The signature was valid, now we ensure the delegation
+            // condition is valid for this event:
+            if cond_query.allows_event(self) {
+                // since this is allowed, we will provide the delegatee
+                Some(delegator.into())
+            } else {
+                debug!("an event failed to satisfy delegation conditions");
+                None
+            }
+        } else {
+            debug!("event had had invalid delegation signature");
+            None
+        }
+    }
+
+    /// Update delegation status
+    pub fn update_delegation(&mut self) {
+        self.delegated_by = self.delegated_author();
+    }
     /// Build an event tag index
-    fn build_index(&mut self) {
+    pub fn build_index(&mut self) {
         // if there are no tags; just leave the index as None
         if self.tags.is_empty() {
             return;
@@ -121,7 +277,7 @@ impl Event {
         let mut idx: HashMap<char, HashSet<String>> = HashMap::new();
         // iterate over tags that have at least 2 elements
         for t in self.tags.iter().filter(|x| x.len() > 1) {
-            let tagname = t.get(0).unwrap();
+            let tagname = t.first().unwrap();
             let tagnamechar_opt = single_char_tagname(tagname);
             if tagnamechar_opt.is_none() {
                 continue;
@@ -129,42 +285,39 @@ impl Event {
             let tagnamechar = tagnamechar_opt.unwrap();
             let tagval = t.get(1).unwrap();
             // ensure a vector exists for this tag
-            if !idx.contains_key(&tagnamechar) {
-                idx.insert(tagnamechar.clone(), HashSet::new());
-            }
+            idx.entry(tagnamechar).or_default();
             // get the tag vec and insert entry
-            let tidx = idx.get_mut(&tagnamechar).expect("could not get tag vector");
-            tidx.insert(tagval.clone());
+            let idx_tag_vec = idx.get_mut(&tagnamechar).expect("could not get tag vector");
+            idx_tag_vec.insert(tagval.clone());
         }
         // save the tag structure
         self.tagidx = Some(idx);
     }
 
     /// Create a short event identifier, suitable for logging.
+    #[must_use]
     pub fn get_event_id_prefix(&self) -> String {
         self.id.chars().take(8).collect()
     }
+    #[must_use]
     pub fn get_author_prefix(&self) -> String {
         self.pubkey.chars().take(8).collect()
     }
 
-    /// Retrieve tag values
+    /// Retrieve tag initial values across all tags matching the name
+    #[must_use]
     pub fn tag_values_by_name(&self, tag_name: &str) -> Vec<String> {
         self.tags
             .iter()
             .filter(|x| x.len() > 1)
-            .filter(|x| x.get(0).unwrap() == tag_name)
-            .map(|x| x.get(1).unwrap().to_owned())
+            .filter(|x| x.first().unwrap() == tag_name)
+            .map(|x| x.get(1).unwrap().clone())
             .collect()
     }
 
-    /// Check if this event has a valid signature.
-    fn is_valid(&self) -> bool {
-        // TODO: return a Result with a reason for invalid events
-        // don't bother to validate an event with a timestamp in the distant future.
-        let config = config::SETTINGS.read().unwrap();
-        let max_future_sec = config.options.reject_future_seconds;
-        if let Some(allowable_future) = max_future_sec {
+    #[must_use]
+    pub fn is_valid_timestamp(&self, reject_future_seconds: Option<usize>) -> bool {
+        if let Some(allowable_future) = reject_future_seconds {
             let curr_time = unix_time();
             // calculate difference, plus how far future we allow
             if curr_time + (allowable_future as u64) < self.created_at {
@@ -176,6 +329,12 @@ impl Event {
                 return false;
             }
         }
+        true
+    }
+
+    /// Check if this event has a valid signature.
+    pub fn validate(&self) -> Result<()> {
+        // TODO: return a Result with a reason for invalid events
         // validation is performed by:
         // * parsing JSON string into event fields
         // * create an array:
@@ -183,44 +342,43 @@ impl Event {
         // * serialize with no spaces/newlines
         let c_opt = self.to_canonical();
         if c_opt.is_none() {
-            debug!("event could not be canonicalized");
-            return false;
+            debug!("could not canonicalize");
+            return Err(EventCouldNotCanonicalize);
         }
         let c = c_opt.unwrap();
         // * compute the sha256sum.
         let digest: sha256::Hash = sha256::Hash::hash(c.as_bytes());
-        let hex_digest = format!("{:x}", digest);
+        let hex_digest = format!("{digest:x}");
         // * ensure the id matches the computed sha256sum.
         if self.id != hex_digest {
             debug!("event id does not match digest");
-            return false;
+            return Err(EventInvalidId);
         }
         // * validate the message digest (sig) using the pubkey & computed sha256 message hash.
-
-        let sig = schnorr::Signature::from_str(&self.sig).unwrap();
+        let sig = schnorr::Signature::from_str(&self.sig).map_err(|_| EventInvalidSignature)?;
         if let Ok(msg) = secp256k1::Message::from_slice(digest.as_ref()) {
             if let Ok(pubkey) = XOnlyPublicKey::from_str(&self.pubkey) {
-                let verify = SECP.verify_schnorr(&sig, &msg, &pubkey);
-                matches!(verify, Ok(()))
+                SECP.verify_schnorr(&sig, &msg, &pubkey)
+                    .map_err(|_| EventInvalidSignature)
             } else {
                 debug!("client sent malformed pubkey");
-                false
+                Err(EventMalformedPubkey)
             }
         } else {
             info!("error converting digest to secp256k1 message");
-            false
+            Err(EventInvalidSignature)
         }
     }
 
     /// Convert event to canonical representation for signing.
-    fn to_canonical(&self) -> Option<String> {
+    pub fn to_canonical(&self) -> Option<String> {
         // create a JsonValue for each event element
         let mut c: Vec<Value> = vec![];
         // id must be set to 0
         let id = Number::from(0_u64);
         c.push(serde_json::Value::Number(id));
         // public key
-        c.push(Value::String(self.pubkey.to_owned()));
+        c.push(Value::String(self.pubkey.clone()));
         // creation time
         let created_at = Number::from(self.created_at);
         c.push(serde_json::Value::Number(created_at));
@@ -230,7 +388,7 @@ impl Event {
         // tags
         c.push(self.tags_to_canonical());
         // content
-        c.push(Value::String(self.content.to_owned()));
+        c.push(Value::String(self.content.clone()));
         serde_json::to_string(&Value::Array(c)).ok()
     }
 
@@ -238,11 +396,11 @@ impl Event {
     fn tags_to_canonical(&self) -> Value {
         let mut tags = Vec::<Value>::new();
         // iterate over self tags,
-        for t in self.tags.iter() {
+        for t in &self.tags {
             // each tag is a vec of strings
             let mut a = Vec::<Value>::new();
             for v in t.iter() {
-                a.push(serde_json::Value::String(v.to_owned()));
+                a.push(serde_json::Value::String(v.clone()));
             }
             tags.push(serde_json::Value::Array(a));
         }
@@ -250,6 +408,7 @@ impl Event {
     }
 
     /// Determine if the given tag and value set intersect with tags in this event.
+    #[must_use]
     pub fn generic_tag_val_intersect(&self, tagname: char, check: &HashSet<String>) -> bool {
         match &self.tagidx {
             // check if this is indexable tagname
@@ -265,65 +424,62 @@ impl Event {
     }
 }
 
-#[cfg(test)]
-mod tests {
-    use super::*;
-    fn simple_event() -> Event {
+impl From<nostr::Event> for Event {
+    fn from(nostr_event: nostr::Event) -> Self {
         Event {
-            id: "0".to_owned(),
-            pubkey: "0".to_owned(),
-            created_at: 0,
-            kind: 0,
-            tags: vec![],
-            content: "".to_owned(),
-            sig: "0".to_owned(),
+            id: nostr_event.id.to_hex(),
+            pubkey: nostr_event.pubkey.to_string(),
+            created_at: nostr_event.created_at.as_u64(),
+            kind: nostr_event.kind.as_u64(),
+            tags: nostr_event.tags.iter().map(|x| x.as_vec()).collect(),
+            content: nostr_event.content,
+            sig: nostr_event.sig.to_string(),
+            delegated_by: None,
             tagidx: None,
         }
     }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
 
     #[test]
     fn event_creation() {
         // create an event
-        let event = simple_event();
+        let event = Event::simple_event();
         assert_eq!(event.id, "0");
     }
 
     #[test]
     fn event_serialize() -> Result<()> {
         // serialize an event to JSON string
-        let event = simple_event();
+        let event = Event::simple_event();
         let j = serde_json::to_string(&event)?;
         assert_eq!(j, "{\"id\":\"0\",\"pubkey\":\"0\",\"created_at\":0,\"kind\":0,\"tags\":[],\"content\":\"\",\"sig\":\"0\"}");
         Ok(())
     }
 
     #[test]
-    fn empty_event_tag_match() -> Result<()> {
-        let event = simple_event();
+    fn empty_event_tag_match() {
+        let event = Event::simple_event();
         assert!(!event
             .generic_tag_val_intersect('e', &HashSet::from(["foo".to_owned(), "bar".to_owned()])));
-        Ok(())
     }
 
     #[test]
-    fn single_event_tag_match() -> Result<()> {
-        let mut event = simple_event();
+    fn single_event_tag_match() {
+        let mut event = Event::simple_event();
         event.tags = vec![vec!["e".to_owned(), "foo".to_owned()]];
         event.build_index();
-        assert_eq!(
-            event.generic_tag_val_intersect(
-                'e',
-                &HashSet::from(["foo".to_owned(), "bar".to_owned()])
-            ),
-            true
-        );
-        Ok(())
+        assert!(event
+            .generic_tag_val_intersect('e', &HashSet::from(["foo".to_owned(), "bar".to_owned()])));
     }
 
     #[test]
     fn event_tags_serialize() -> Result<()> {
         // serialize an event with tags to JSON string
-        let mut event = simple_event();
+        let mut event = Event::simple_event();
         event.tags = vec![
             vec![
                 "e".to_owned(),
@@ -355,7 +511,8 @@ mod tests {
         let e = Event {
             id: "999".to_owned(),
             pubkey: "012345".to_owned(),
-            created_at: 501234,
+            delegated_by: None,
+            created_at: 501_234,
             kind: 1,
             tags: vec![],
             content: "this is a test".to_owned(),
@@ -372,7 +529,8 @@ mod tests {
         let e = Event {
             id: "999".to_owned(),
             pubkey: "012345".to_owned(),
-            created_at: 501234,
+            delegated_by: None,
+            created_at: 501_234,
             kind: 1,
             tags: vec![
                 vec!["j".to_owned(), "abc".to_owned()],
@@ -393,12 +551,40 @@ mod tests {
         assert_eq!(v, vec!["foo", "bar", "baz"]);
     }
 
+    #[test]
+    fn event_no_tag_select() {
+        let e = Event {
+            id: "999".to_owned(),
+            pubkey: "012345".to_owned(),
+            delegated_by: None,
+            created_at: 501_234,
+            kind: 1,
+            tags: vec![
+                vec!["j".to_owned(), "abc".to_owned()],
+                vec!["e".to_owned(), "foo".to_owned()],
+                vec!["e".to_owned(), "baz".to_owned()],
+                vec![
+                    "p".to_owned(),
+                    "aaaa".to_owned(),
+                    "ws://example.com".to_owned(),
+                ],
+            ],
+            content: "this is a test".to_owned(),
+            sig: "abcde".to_owned(),
+            tagidx: None,
+        };
+        let v = e.tag_values_by_name("x");
+        // asking for tags that don't exist just returns zero-length vector
+        assert_eq!(v.len(), 0);
+    }
+
     #[test]
     fn event_canonical_with_tags() {
         let e = Event {
             id: "999".to_owned(),
             pubkey: "012345".to_owned(),
-            created_at: 501234,
+            delegated_by: None,
+            created_at: 501_234,
             kind: 1,
             tags: vec![
                 vec!["#e".to_owned(), "aoeu".to_owned()],
@@ -417,4 +603,188 @@ mod tests {
         let expected = Some(expected_json.to_owned());
         assert_eq!(c, expected);
     }
+
+    #[test]
+    fn ephemeral_event() {
+        let mut event = Event::simple_event();
+        event.kind = 20000;
+        assert!(event.is_ephemeral());
+        event.kind = 29999;
+        assert!(event.is_ephemeral());
+        event.kind = 30000;
+        assert!(!event.is_ephemeral());
+        event.kind = 19999;
+        assert!(!event.is_ephemeral());
+    }
+
+    #[test]
+    fn replaceable_event() {
+        let mut event = Event::simple_event();
+        event.kind = 0;
+        assert!(event.is_replaceable());
+        event.kind = 3;
+        assert!(event.is_replaceable());
+        event.kind = 10000;
+        assert!(event.is_replaceable());
+        event.kind = 19999;
+        assert!(event.is_replaceable());
+        event.kind = 20000;
+        assert!(!event.is_replaceable());
+    }
+
+    #[test]
+    fn param_replaceable_event() {
+        let mut event = Event::simple_event();
+        event.kind = 30000;
+        assert!(event.is_param_replaceable());
+        event.kind = 39999;
+        assert!(event.is_param_replaceable());
+        event.kind = 29999;
+        assert!(!event.is_param_replaceable());
+        event.kind = 40000;
+        assert!(!event.is_param_replaceable());
+    }
+
+    #[test]
+    fn param_replaceable_value_case_1() {
+        // NIP case #1: "tags":[["d",""]]
+        let mut event = Event::simple_event();
+        event.kind = 30000;
+        event.tags = vec![vec!["d".to_owned(), "".to_owned()]];
+        assert_eq!(event.distinct_param(), Some("".to_string()));
+    }
+
+    #[test]
+    fn param_replaceable_value_case_2() {
+        // NIP case #2: "tags":[]: implicit d tag with empty value
+        let mut event = Event::simple_event();
+        event.kind = 30000;
+        assert_eq!(event.distinct_param(), Some("".to_string()));
+    }
+
+    #[test]
+    fn param_replaceable_value_case_3() {
+        // NIP case #3: "tags":[["d"]]: implicit empty value ""
+        let mut event = Event::simple_event();
+        event.kind = 30000;
+        event.tags = vec![vec!["d".to_owned()]];
+        assert_eq!(event.distinct_param(), Some("".to_string()));
+    }
+
+    #[test]
+    fn param_replaceable_value_case_4() {
+        // NIP case #4: "tags":[["d",""],["d","not empty"]]: only first d tag is considered
+        let mut event = Event::simple_event();
+        event.kind = 30000;
+        event.tags = vec![
+            vec!["d".to_owned(), "".to_string()],
+            vec!["d".to_owned(), "not empty".to_string()],
+        ];
+        assert_eq!(event.distinct_param(), Some("".to_string()));
+    }
+
+    #[test]
+    fn param_replaceable_value_case_4b() {
+        // Variation of #4 with
+        // NIP case #4: "tags":[["d","not empty"],["d",""]]: only first d tag is considered
+        let mut event = Event::simple_event();
+        event.kind = 30000;
+        event.tags = vec![
+            vec!["d".to_owned(), "not empty".to_string()],
+            vec!["d".to_owned(), "".to_string()],
+        ];
+        assert_eq!(event.distinct_param(), Some("not empty".to_string()));
+    }
+
+    #[test]
+    fn param_replaceable_value_case_5() {
+        // NIP case #5: "tags":[["d"],["d","some value"]]: only first d tag is considered
+        let mut event = Event::simple_event();
+        event.kind = 30000;
+        event.tags = vec![
+            vec!["d".to_owned()],
+            vec!["d".to_owned(), "second value".to_string()],
+            vec!["d".to_owned(), "third value".to_string()],
+        ];
+        assert_eq!(event.distinct_param(), Some("".to_string()));
+    }
+
+    #[test]
+    fn param_replaceable_value_case_6() {
+        // NIP case #6: "tags":[["e"]]: same as no tags
+        let mut event = Event::simple_event();
+        event.kind = 30000;
+        event.tags = vec![vec!["e".to_owned()]];
+        assert_eq!(event.distinct_param(), Some("".to_string()));
+    }
+
+    #[test]
+    fn expiring_event_none() {
+        // regular events do not expire
+        let mut event = Event::simple_event();
+        event.kind = 7;
+        event.tags = vec![vec!["test".to_string(), "foo".to_string()]];
+        assert_eq!(event.expiration(), None);
+    }
+
+    #[test]
+    fn expiring_event_empty() {
+        // regular events do not expire
+        let mut event = Event::simple_event();
+        event.kind = 7;
+        event.tags = vec![vec!["expiration".to_string()]];
+        assert_eq!(event.expiration(), None);
+    }
+
+    #[test]
+    fn expiring_event_future() {
+        // a normal expiring event
+        let exp: u64 = 1676264138;
+        let mut event = Event::simple_event();
+        event.kind = 1;
+        event.tags = vec![vec!["expiration".to_string(), exp.to_string()]];
+        assert_eq!(event.expiration(), Some(exp));
+    }
+
+    #[test]
+    fn expiring_event_negative() {
+        // expiration set to a negative value (invalid)
+        let exp: i64 = -90;
+        let mut event = Event::simple_event();
+        event.kind = 1;
+        event.tags = vec![vec!["expiration".to_string(), exp.to_string()]];
+        assert_eq!(event.expiration(), None);
+    }
+
+    #[test]
+    fn expiring_event_zero() {
+        // a normal expiring event set to zero
+        let exp: i64 = 0;
+        let mut event = Event::simple_event();
+        event.kind = 1;
+        event.tags = vec![vec!["expiration".to_string(), exp.to_string()]];
+        assert_eq!(event.expiration(), Some(0));
+    }
+
+    #[test]
+    fn expiring_event_fraction() {
+        // expiration is fractional (invalid)
+        let exp: f64 = 23.334;
+        let mut event = Event::simple_event();
+        event.kind = 1;
+        event.tags = vec![vec!["expiration".to_string(), exp.to_string()]];
+        assert_eq!(event.expiration(), None);
+    }
+
+    #[test]
+    fn expiring_event_multiple() {
+        // multiple values, we just take the first
+        let mut event = Event::simple_event();
+        event.kind = 1;
+        event.tags = vec![
+            vec!["expiration".to_string(), (10).to_string()],
+            vec!["expiration".to_string(), (20).to_string()],
+        ];
+        assert_eq!(event.expiration(), Some(10));
+    }
 }

src/hexrange.rs

@@ -1,159 +0,0 @@
-//! Utilities for searching hexadecimal
-use crate::utils::is_hex;
-use hex;
-
-/// Types of hexadecimal queries.
-#[derive(PartialEq, Debug, Clone)]
-pub enum HexSearch {
-    // when no range is needed, exact 32-byte
-    Exact(Vec<u8>),
-    // lower (inclusive) and upper range (exclusive)
-    Range(Vec<u8>, Vec<u8>),
-    // lower bound only, upper bound is MAX inclusive
-    LowerOnly(Vec<u8>),
-}
-
-/// Check if a string contains only f chars
-fn is_all_fs(s: &str) -> bool {
-    s.chars().all(|x| x == 'f' || x == 'F')
-}
-
-/// Find the next hex sequence greater than the argument.
-pub fn hex_range(s: &str) -> Option<HexSearch> {
-    // handle special cases
-    if !is_hex(s) || s.len() > 64 {
-        return None;
-    }
-    if s.len() == 64 {
-        return Some(HexSearch::Exact(hex::decode(s).ok()?));
-    }
-    // if s is odd, add a zero
-    let mut hash_base = s.to_owned();
-    let mut odd = hash_base.len() % 2 != 0;
-    if odd {
-        // extend the string to make it even
-        hash_base.push('0');
-    }
-    let base = hex::decode(hash_base).ok()?;
-    // check for all ff's
-    if is_all_fs(s) {
-        // there is no higher bound, we only want to search for blobs greater than this.
-        return Some(HexSearch::LowerOnly(base));
-    }
-
-    // return a range
-    let mut upper = base.clone();
-    let mut byte_len = upper.len();
-
-    // for odd strings, we made them longer, but we want to increment the upper char (+16).
-    // we know we can do this without overflowing because we explicitly set the bottom half to 0's.
-    while byte_len > 0 {
-        byte_len -= 1;
-        // check if byte can be incremented, or if we need to carry.
-        let b = upper[byte_len];
-        if b == u8::MAX {
-            // reset and carry
-            upper[byte_len] = 0;
-        } else if odd {
-            // check if first char in this byte is NOT 'f'
-            if b < 240 {
-                upper[byte_len] = b + 16; // bump up the first character in this byte
-                                          // increment done, stop iterating through the vec
-                break;
-            } else {
-                // if it is 'f', reset the byte to 0 and do a carry
-                // reset and carry
-                upper[byte_len] = 0;
-            }
-            // done with odd logic, so don't repeat this
-            odd = false;
-        } else {
-            // bump up the first character in this byte
-            upper[byte_len] = b + 1;
-            // increment done, stop iterating
-            break;
-        }
-    }
-    Some(HexSearch::Range(base, upper))
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::error::Result;
-
-    #[test]
-    fn hex_range_exact() -> Result<()> {
-        let hex = "abcdef00abcdef00abcdef00abcdef00abcdef00abcdef00abcdef00abcdef00";
-        let r = hex_range(hex);
-        assert_eq!(
-            r,
-            Some(HexSearch::Exact(hex::decode(hex).expect("invalid hex")))
-        );
-        Ok(())
-    }
-    #[test]
-    fn hex_full_range() -> Result<()> {
-        let hex = "aaaa";
-        let hex_upper = "aaab";
-        let r = hex_range(hex);
-        assert_eq!(
-            r,
-            Some(HexSearch::Range(
-                hex::decode(hex).expect("invalid hex"),
-                hex::decode(hex_upper).expect("invalid hex")
-            ))
-        );
-        Ok(())
-    }
-
-    #[test]
-    fn hex_full_range_odd() -> Result<()> {
-        let r = hex_range("abc");
-        assert_eq!(
-            r,
-            Some(HexSearch::Range(
-                hex::decode("abc0").expect("invalid hex"),
-                hex::decode("abd0").expect("invalid hex")
-            ))
-        );
-        Ok(())
-    }
-
-    #[test]
-    fn hex_full_range_odd_end_f() -> Result<()> {
-        let r = hex_range("abf");
-        assert_eq!(
-            r,
-            Some(HexSearch::Range(
-                hex::decode("abf0").expect("invalid hex"),
-                hex::decode("ac00").expect("invalid hex")
-            ))
-        );
-        Ok(())
-    }
-
-    #[test]
-    fn hex_no_upper() -> Result<()> {
-        let r = hex_range("ffff");
-        assert_eq!(
-            r,
-            Some(HexSearch::LowerOnly(
-                hex::decode("ffff").expect("invalid hex")
-            ))
-        );
-        Ok(())
-    }
-
-    #[test]
-    fn hex_no_upper_odd() -> Result<()> {
-        let r = hex_range("fff");
-        assert_eq!(
-            r,
-            Some(HexSearch::LowerOnly(
-                hex::decode("fff0").expect("invalid hex")
-            ))
-        );
-        Ok(())
-    }
-}

src/info.rs

@@ -1,9 +1,38 @@
 //! Relay metadata using NIP-11
 /// Relay Info
-use crate::config;
+use crate::config::Settings;
 use serde::{Deserialize, Serialize};
 
 pub const CARGO_PKG_VERSION: Option<&'static str> = option_env!("CARGO_PKG_VERSION");
+pub const UNIT: &str = "msats";
+
+/// Limitations of the relay as specified in NIP-111
+/// (This nip isn't finalized so may change)
+#[derive(Debug, Serialize, Deserialize)]
+#[allow(unused)]
+pub struct Limitation {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    payment_required: Option<bool>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    restricted_writes: Option<bool>,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[allow(unused)]
+pub struct Fees {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    admission: Option<Vec<Fee>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    publication: Option<Vec<Fee>>,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[allow(unused)]
+pub struct Fee {
+    amount: u64,
+    unit: String,
+}
 
 #[derive(Debug, Serialize, Deserialize)]
 #[allow(unused)]
@@ -19,25 +48,94 @@ pub struct RelayInfo {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub contact: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
+    pub icon: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub supported_nips: Option<Vec<i64>>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub software: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub version: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub limitation: Option<Limitation>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub payment_url: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub fees: Option<Fees>,
 }
 
 /// Convert an Info configuration into public Relay Info
-impl From<config::Info> for RelayInfo {
-    fn from(i: config::Info) -> Self {
+impl From<Settings> for RelayInfo {
+    fn from(c: Settings) -> Self {
+        let mut supported_nips = vec![1, 2, 9, 11, 12, 15, 16, 20, 22, 33, 40];
+
+        if c.authorization.nip42_auth {
+            supported_nips.push(42);
+            supported_nips.sort();
+        }
+
+        let i = c.info;
+        let p = c.pay_to_relay;
+
+        let limitations = Limitation {
+            payment_required: Some(p.enabled),
+            restricted_writes: Some(
+                p.enabled
+                    || c.verified_users.is_enabled()
+                    || c.authorization.pubkey_whitelist.is_some()
+                    || c.grpc.restricts_write,
+            ),
+        };
+
+        let (payment_url, fees) = if p.enabled {
+            let admission_fee = if p.admission_cost > 0 {
+                Some(vec![Fee {
+                    amount: p.admission_cost * 1000,
+                    unit: UNIT.to_string(),
+                }])
+            } else {
+                None
+            };
+
+            let post_fee = if p.cost_per_event > 0 {
+                Some(vec![Fee {
+                    amount: p.cost_per_event * 1000,
+                    unit: UNIT.to_string(),
+                }])
+            } else {
+                None
+            };
+
+            let fees = Fees {
+                admission: admission_fee,
+                publication: post_fee,
+            };
+
+            let payment_url = if p.enabled && i.relay_url.is_some() {
+                Some(format!(
+                    "{}join",
+                    i.relay_url.clone().unwrap().replace("ws", "http")
+                ))
+            } else {
+                None
+            };
+            (payment_url, Some(fees))
+        } else {
+            (None, None)
+        };
+
         RelayInfo {
             id: i.relay_url,
             name: i.name,
             description: i.description,
             pubkey: i.pubkey,
             contact: i.contact,
-            supported_nips: Some(vec![1, 2, 11, 15, 16]),
+            supported_nips: Some(supported_nips),
             software: Some("https://git.sr.ht/~gheartsfield/nostr-rs-relay".to_owned()),
-            version: CARGO_PKG_VERSION.map(|x| x.to_owned()),
+            version: CARGO_PKG_VERSION.map(std::borrow::ToOwned::to_owned),
+            limitation: Some(limitations),
+            payment_url,
+            fees,
+            icon: i.relay_icon,
         }
     }
 }

src/lib.rs

@@ -1,12 +1,18 @@
+pub mod cli;
 pub mod close;
 pub mod config;
 pub mod conn;
 pub mod db;
+pub mod delegation;
 pub mod error;
 pub mod event;
-pub mod hexrange;
 pub mod info;
+pub mod nauthz;
 pub mod nip05;
-pub mod schema;
+pub mod notice;
+pub mod repo;
 pub mod subscription;
 pub mod utils;
+// Public API for creating relays programmatically
+pub mod payment;
+pub mod server;

src/main.rs

@@ -1,591 +1,109 @@
 //! Server process
-use futures::SinkExt;
-use futures::StreamExt;
-use hyper::header::ACCEPT;
-use hyper::service::{make_service_fn, service_fn};
-use hyper::upgrade::Upgraded;
-use hyper::{
-    header, server::conn::AddrStream, upgrade, Body, Request, Response, Server, StatusCode,
-};
-use log::*;
-use nostr_rs_relay::close::Close;
-use nostr_rs_relay::close::CloseCmd;
+use clap::Parser;
+use console_subscriber::ConsoleLayer;
+use nostr_rs_relay::cli::CLIArgs;
 use nostr_rs_relay::config;
-use nostr_rs_relay::conn;
-use nostr_rs_relay::db;
-use nostr_rs_relay::db::SubmittedEvent;
-use nostr_rs_relay::error::{Error, Result};
-use nostr_rs_relay::event::Event;
-use nostr_rs_relay::event::EventCmd;
-use nostr_rs_relay::info::RelayInfo;
-use nostr_rs_relay::nip05;
-use nostr_rs_relay::subscription::Subscription;
-use serde::{Deserialize, Serialize};
-use serde_json::json;
-use std::collections::HashMap;
-use std::convert::Infallible;
-use std::env;
-use std::net::SocketAddr;
+use nostr_rs_relay::server::start_server;
+use std::fs;
 use std::path::Path;
-use std::time::Duration;
-use std::time::Instant;
-use tokio::runtime::Builder;
-use tokio::sync::broadcast::{self, Receiver, Sender};
-use tokio::sync::mpsc;
-use tokio::sync::oneshot;
-use tokio_tungstenite::WebSocketStream;
-use tungstenite::error::Error as WsError;
-use tungstenite::handshake;
-use tungstenite::protocol::Message;
-use tungstenite::protocol::WebSocketConfig;
+use std::process;
+use std::sync::mpsc as syncmpsc;
+use std::sync::mpsc::{Receiver as MpscReceiver, Sender as MpscSender};
+use std::thread;
+#[cfg(all(not(target_env = "msvc"), not(target_os = "openbsd")))]
+use tikv_jemallocator::Jemalloc;
+use tracing::info;
+use tracing_appender::non_blocking::WorkerGuard;
+use tracing_subscriber::EnvFilter;
 
-/// Return a requested DB name from command line arguments.
-fn db_from_args(args: Vec<String>) -> Option<String> {
-    if args.len() == 3 && args.get(1) == Some(&"--db".to_owned()) {
-        return args.get(2).map(|x| x.to_owned());
-    }
-    None
-}
-
-/// Handle arbitrary HTTP requests, including for WebSocket upgrades.
-async fn handle_web_request(
-    mut request: Request<Body>,
-    pool: db::SqlitePool,
-    remote_addr: SocketAddr,
-    broadcast: Sender<Event>,
-    event_tx: tokio::sync::mpsc::Sender<SubmittedEvent>,
-    shutdown: Receiver<()>,
-) -> Result<Response<Body>, Infallible> {
-    match (
-        request.uri().path(),
-        request.headers().contains_key(header::UPGRADE),
-    ) {
-        // Request for / as websocket
-        ("/", true) => {
-            trace!("websocket with upgrade request");
-            //assume request is a handshake, so create the handshake response
-            let response = match handshake::server::create_response_with_body(&request, || {
-                Body::empty()
-            }) {
-                Ok(response) => {
-                    //in case the handshake response creation succeeds,
-                    //spawn a task to handle the websocket connection
-                    tokio::spawn(async move {
-                        //using the hyper feature of upgrading a connection
-                        match upgrade::on(&mut request).await {
-                            //if successfully upgraded
-                            Ok(upgraded) => {
-                                // set WebSocket configuration options
-                                let mut config = WebSocketConfig::default();
-                                {
-                                    let settings = config::SETTINGS.read().unwrap();
-                                    config.max_message_size = settings.limits.max_ws_message_bytes;
-                                    config.max_frame_size = settings.limits.max_ws_frame_bytes;
-                                }
-                                //create a websocket stream from the upgraded object
-                                let ws_stream = WebSocketStream::from_raw_socket(
-                                    //pass the upgraded object
-                                    //as the base layer stream of the Websocket
-                                    upgraded,
-                                    tokio_tungstenite::tungstenite::protocol::Role::Server,
-                                    Some(config),
-                                )
-                                .await;
-
-                                tokio::spawn(nostr_server(
-                                    pool, ws_stream, broadcast, event_tx, shutdown,
-                                ));
-                            }
-                            Err(e) => println!(
-                                "error when trying to upgrade connection \
-                                 from address {} to websocket connection. \
-                                 Error is: {}",
-                                remote_addr, e
-                            ),
-                        }
-                    });
-                    //return the response to the handshake request
-                    response
-                }
-                Err(error) => {
-                    warn!("websocket response failed");
-                    let mut res =
-                        Response::new(Body::from(format!("Failed to create websocket: {}", error)));
-                    *res.status_mut() = StatusCode::BAD_REQUEST;
-                    return Ok(res);
-                }
-            };
-            Ok::<_, Infallible>(response)
-        }
-        // Request for Relay info
-        ("/", false) => {
-            // handle request at root with no upgrade header
-            // Check if this is a nostr server info request
-            let accept_header = &request.headers().get(ACCEPT);
-            // check if application/nostr+json is included
-            if let Some(media_types) = accept_header {
-                if let Ok(mt_str) = media_types.to_str() {
-                    if mt_str.contains("application/nostr+json") {
-                        let config = config::SETTINGS.read().unwrap();
-                        // build a relay info response
-                        debug!("Responding to server info request");
-                        let rinfo = RelayInfo::from(config.info.clone());
-                        let b = Body::from(serde_json::to_string_pretty(&rinfo).unwrap());
-                        return Ok(Response::builder()
-                            .status(200)
-                            .header("Content-Type", "application/nostr+json")
-                            .header("Access-Control-Allow-Origin", "*")
-                            .body(b)
-                            .unwrap());
-                    }
-                }
-            }
-            Ok(Response::builder()
-                .status(200)
-                .header("Content-Type", "text/plain")
-                .body(Body::from("Please use a Nostr client to connect."))
-                .unwrap())
-        }
-        (_, _) => {
-            //handle any other url
-            Ok(Response::builder()
-                .status(StatusCode::NOT_FOUND)
-                .body(Body::from("Nothing here."))
-                .unwrap())
-        }
-    }
-}
-
-async fn shutdown_signal() {
-    // Wait for the CTRL+C signal
-    tokio::signal::ctrl_c()
-        .await
-        .expect("failed to install CTRL+C signal handler");
-}
+#[cfg(all(not(target_env = "msvc"), not(target_os = "openbsd")))]
+#[global_allocator]
+static GLOBAL: Jemalloc = Jemalloc;
 
 /// Start running a Nostr relay server.
-fn main() -> Result<(), Error> {
-    // setup logger
-    let _ = env_logger::try_init();
-    // get database directory from args
-    let args: Vec<String> = env::args().collect();
-    let db_dir: Option<String> = db_from_args(args);
-    {
-        let mut settings = config::SETTINGS.write().unwrap();
-        // replace default settings with those read from config.toml
-        let mut c = config::Settings::new();
-        // update with database location
-        if let Some(db) = db_dir {
-            c.database.data_directory = db;
+fn main() {
+    let args = CLIArgs::parse();
+
+    // get config file name from args
+    let config_file_arg = args.config;
+
+    // Ensure the config file is readable if it was explicitly set
+    if let Some(config_path) = config_file_arg.as_ref() {
+        let path = Path::new(&config_path);
+        if !path.exists() {
+            eprintln!("Config file not found: {}", &config_path);
+            process::exit(1);
+        }
+        if !path.is_file() {
+            eprintln!("Invalid config file path: {}", &config_path);
+            process::exit(1);
+        }
+        if let Err(err) = fs::metadata(path) {
+            eprintln!("Error while accessing file metadata: {}", err);
+            process::exit(1);
+        }
+        if let Err(err) = fs::File::open(path) {
+            eprintln!("Config file is not readable: {}", err);
+            process::exit(1);
         }
-        *settings = c;
     }
 
-    let settings = config::SETTINGS.read().unwrap();
-    trace!("Config: {:?}", settings);
-    // do some config validation.
-    if !Path::new(&settings.database.data_directory).is_dir() {
-        error!("Database directory does not exist");
-        return Err(Error::DatabaseDirError);
-    }
-    let addr = format!(
-        "{}:{}",
-        settings.network.address.trim(),
-        settings.network.port
-    );
-    let socket_addr = addr.parse().expect("listening address not valid");
-    // address whitelisting settings
-    if let Some(addr_whitelist) = &settings.authorization.pubkey_whitelist {
-        info!(
-            "Event publishing restricted to {} pubkey(s)",
-            addr_whitelist.len()
-        );
-    }
-    // check if NIP-05 enforced user verification is on
-    if settings.verified_users.is_active() {
-        info!(
-            "NIP-05 user verification mode:{:?}",
-            settings.verified_users.mode
-        );
-        if let Some(d) = settings.verified_users.verify_update_duration() {
-            info!("NIP-05 check user verification every:   {:?}", d);
-        }
-        if let Some(d) = settings.verified_users.verify_expiration_duration() {
-            info!("NIP-05 user verification expires after: {:?}", d);
-        }
-        if let Some(wl) = &settings.verified_users.domain_whitelist {
-            info!("NIP-05 domain whitelist: {:?}", wl);
-        }
-        if let Some(bl) = &settings.verified_users.domain_blacklist {
-            info!("NIP-05 domain blacklist: {:?}", bl);
-        }
-    }
-    // configure tokio runtime
-    let rt = Builder::new_multi_thread()
-        .enable_all()
-        .thread_name("tokio-ws")
-        .build()
-        .unwrap();
-    // start tokio
-    rt.block_on(async {
-        let settings = config::SETTINGS.read().unwrap();
-        info!("listening on: {}", socket_addr);
-        // all client-submitted valid events are broadcast to every
-        // other client on this channel.  This should be large enough
-        // to accomodate slower readers (messages are dropped if
-        // clients can not keep up).
-        let (bcast_tx, _) = broadcast::channel::<Event>(settings.limits.broadcast_buffer);
-        // validated events that need to be persisted are sent to the
-        // database on via this channel.
-        let (event_tx, event_rx) =
-            mpsc::channel::<SubmittedEvent>(settings.limits.event_persist_buffer);
-        // establish a channel for letting all threads now about a
-        // requested server shutdown.
-        let (invoke_shutdown, shutdown_listen) = broadcast::channel::<()>(1);
-        // create a channel for sending any new metadata event.  These
-        // will get processed relatively slowly (a potentially
-        // multi-second blocking HTTP call) on a single thread, so we
-        // buffer requests on the channel.  No harm in dropping events
-        // here, since we are protecting against DoS.  This can make
-        // it difficult to setup initial metadata in bulk, since
-        // overwhelming this will drop events and won't register
-        // metadata events.
-        let (metadata_tx, metadata_rx) = broadcast::channel::<Event>(4096);
-        // start the database writer thread.  Give it a channel for
-        // writing events, and for publishing events that have been
-        // written (to all connected clients).
-        db::db_writer(
-            event_rx,
-            bcast_tx.clone(),
-            metadata_tx.clone(),
-            shutdown_listen,
-        )
-        .await;
-        info!("db writer created");
+    let mut _log_guard: Option<WorkerGuard> = None;
 
-        // create a nip-05 verifier thread
-        let verifier_opt = nip05::Verifier::new(metadata_rx, bcast_tx.clone());
-        if let Ok(mut v) = verifier_opt {
-            if settings.verified_users.is_active() {
-                tokio::task::spawn(async move {
-                    info!("starting up NIP-05 verifier...");
-                    v.run().await;
-                });
-            }
-        }
-        // // listen for ctrl-c interruupts
-        let ctrl_c_shutdown = invoke_shutdown.clone();
-        tokio::spawn(async move {
-            tokio::signal::ctrl_c().await.unwrap();
-            info!("shutting down due to SIGINT");
-            ctrl_c_shutdown.send(()).ok();
-        });
-        // build a connection pool for sqlite connections
-        let pool = db::build_pool(
-            "client query",
-            rusqlite::OpenFlags::SQLITE_OPEN_READ_ONLY
-                | rusqlite::OpenFlags::SQLITE_OPEN_SHARED_CACHE,
-            settings.database.min_conn,
-            settings.database.max_conn,
-            true,
-        );
-        // A `Service` is needed for every connection, so this
-        // creates one from our `handle_request` function.
-        let make_svc = make_service_fn(|conn: &AddrStream| {
-            let svc_pool = pool.clone();
-            let remote_addr = conn.remote_addr();
-            let bcast = bcast_tx.clone();
-            let event = event_tx.clone();
-            let stop = invoke_shutdown.clone();
-            async move {
-                // service_fn converts our function into a `Service`
-                Ok::<_, Infallible>(service_fn(move |request: Request<Body>| {
-                    handle_web_request(
-                        request,
-                        svc_pool.clone(),
-                        remote_addr,
-                        bcast.clone(),
-                        event.clone(),
-                        stop.subscribe(),
-                    )
-                }))
-            }
-        });
-        let server = Server::bind(&socket_addr)
-            .serve(make_svc)
-            .with_graceful_shutdown(shutdown_signal());
-        // run hyper
-        if let Err(e) = server.await {
-            eprintln!("server error: {}", e);
-        }
-        // our code
+    // configure settings from the config file (defaults to config.toml)
+    // replace default settings with those read from the config file
+    let mut settings = config::Settings::new(&config_file_arg).unwrap_or_else(|e| {
+        eprintln!("Error reading config file ({:?})", e);
+        process::exit(1);
     });
-    Ok(())
-}
 
-/// Nostr protocol messages from a client
-#[derive(Deserialize, Serialize, Clone, PartialEq, Debug)]
-#[serde(untagged)]
-pub enum NostrMessage {
-    /// An `EVENT` message
-    EventMsg(EventCmd),
-    /// A `REQ` message
-    SubMsg(Subscription),
-    /// A `CLOSE` message
-    CloseMsg(CloseCmd),
-}
+    // setup tracing
+    if settings.diagnostics.tracing {
+        // enable tracing with tokio-console
+        ConsoleLayer::builder().with_default_env().init();
+    } else {
+        // standard logging
+        if let Some(path) = &settings.logging.folder_path {
+            // write logs to a folder
+            let prefix = match &settings.logging.file_prefix {
+                Some(p) => p.as_str(),
+                None => "relay",
+            };
+            let file_appender = tracing_appender::rolling::daily(path, prefix);
+            let (non_blocking, guard) = tracing_appender::non_blocking(file_appender);
+            let filter = EnvFilter::from_default_env();
+            // assign to a variable that is not dropped till the program ends
+            _log_guard = Some(guard);
 
-/// Convert Message to NostrMessage
-fn convert_to_msg(msg: String) -> Result<NostrMessage> {
-    let config = config::SETTINGS.read().unwrap();
-    let parsed_res: Result<NostrMessage> = serde_json::from_str(&msg).map_err(|e| e.into());
-    match parsed_res {
-        Ok(m) => {
-            if let NostrMessage::EventMsg(_) = m {
-                if let Some(max_size) = config.limits.max_event_bytes {
-                    // check length, ensure that some max size is set.
-                    if msg.len() > max_size && max_size > 0 {
-                        return Err(Error::EventMaxLengthError(msg.len()));
-                    }
-                }
-            }
-            Ok(m)
-        }
-        Err(e) => {
-            debug!("proto parse error: {:?}", e);
-            debug!("parse error on message: {}", msg.trim());
-            Err(Error::ProtoParseError)
+            tracing_subscriber::fmt()
+                .with_env_filter(filter)
+                .with_writer(non_blocking)
+                .try_init()
+                .unwrap();
+        } else {
+            // write to stdout
+            tracing_subscriber::fmt::try_init().unwrap();
         }
     }
-}
+    info!("Starting up from main");
 
-/// Turn a string into a NOTICE message ready to send over a WebSocket
-fn make_notice_message(msg: &str) -> Message {
-    Message::text(json!(["NOTICE", msg]).to_string())
-}
+    // get database directory from args
+    let db_dir_arg = args.db;
 
-/// Handle new client connections.  This runs through an event loop
-/// for all client communication.
-async fn nostr_server(
-    pool: db::SqlitePool,
-    mut ws_stream: WebSocketStream<Upgraded>,
-    broadcast: Sender<Event>,
-    event_tx: mpsc::Sender<SubmittedEvent>,
-    mut shutdown: Receiver<()>,
-) {
-    // get a broadcast channel for clients to communicate on
-    let mut bcast_rx = broadcast.subscribe();
-    // Track internal client state
-    let mut conn = conn::ClientConn::new();
-    let cid = conn.get_client_prefix();
-    // Create a channel for receiving query results from the database.
-    // we will send out the tx handle to any query we generate.
-    let (query_tx, mut query_rx) = mpsc::channel::<db::QueryResult>(256);
-    // Create channel for receiving NOTICEs
-    let (notice_tx, mut notice_rx) = mpsc::channel::<String>(32);
-
-    // last time this client sent data (message, ping, etc.)
-    let mut last_message_time = Instant::now();
-
-    // ping interval (every 5 minutes)
-    let default_ping_dur = Duration::from_secs(300);
-
-    // disconnect after 20 minutes without a ping response or event.
-    let max_quiet_time = Duration::from_secs(60 * 20);
-
-    let start = tokio::time::Instant::now() + default_ping_dur;
-    let mut ping_interval = tokio::time::interval_at(start, default_ping_dur);
-
-    // maintain a hashmap of a oneshot channel for active subscriptions.
-    // when these subscriptions are cancelled, make a message
-    // available to the executing query so it knows to stop.
-    let mut running_queries: HashMap<String, oneshot::Sender<()>> = HashMap::new();
-
-    // for stats, keep track of how many events the client published,
-    // and how many it received from queries.
-    let mut client_published_event_count: usize = 0;
-    let mut client_received_event_count: usize = 0;
-    info!("new connection for client: {:?}", cid);
-    loop {
-        tokio::select! {
-            _ = shutdown.recv() => {
-                // server shutting down, exit loop
-                break;
-            },
-            _ = ping_interval.tick() => {
-                // check how long since we talked to client
-                // if it has been too long, disconnect
-                if last_message_time.elapsed() > max_quiet_time {
-                    debug!("ending connection due to lack of client ping response");
-                    break;
-                }
-                // Send a ping
-                ws_stream.send(Message::Ping(Vec::new())).await.ok();
-            },
-            Some(notice_msg) = notice_rx.recv() => {
-                ws_stream.send(make_notice_message(&notice_msg)).await.ok();
-            },
-            Some(query_result) = query_rx.recv() => {
-                // database informed us of a query result we asked for
-                let subesc = query_result.sub_id.replace("\"", "");
-                if query_result.event == "EOSE" {
-                    let send_str = format!("[\"EOSE\",\"{}\"]", subesc);
-                    ws_stream.send(Message::Text(send_str)).await.ok();
-                } else {
-                    client_received_event_count += 1;
-                    // send a result
-                    let send_str = format!("[\"EVENT\",\"{}\",{}]", subesc, &query_result.event);
-                    ws_stream.send(Message::Text(send_str)).await.ok();
-                }
-            },
-            // TODO: consider logging the LaggedRecv error
-            Ok(global_event) = bcast_rx.recv() => {
-                // an event has been broadcast to all clients
-                // first check if there is a subscription for this event.
-                let matching_subs = conn.get_matching_subscriptions(&global_event);
-                for s in matching_subs {
-                    // TODO: serialize at broadcast time, instead of
-                    // once for each consumer.
-                    if let Ok(event_str) = serde_json::to_string(&global_event) {
-                        debug!("sub match: client: {:?}, sub: {:?}, event: {:?}",
-                               cid, s,
-                               global_event.get_event_id_prefix());
-                        // create an event response and send it
-                        let subesc = s.replace("\"", "");
-                        ws_stream.send(Message::Text(format!("[\"EVENT\",\"{}\",{}]", subesc, event_str))).await.ok();
-                        //nostr_stream.send(res).await.ok();
-                    } else {
-                        warn!("could not serialize event {:?}", global_event.get_event_id_prefix());
-                    }
-                }
-            },
-            ws_next = ws_stream.next() => {
-                // update most recent message time for client
-                last_message_time = Instant::now();
-                // Consume text messages from the client, parse into Nostr messages.
-                let nostr_msg = match ws_next {
-                    Some(Ok(Message::Text(m))) => {
-                        convert_to_msg(m)
-                    },
-                    Some(Ok(Message::Binary(_))) => {
-                        ws_stream.send(make_notice_message("binary messages are not accepted")).await.ok();
-                        continue;
-                    },
-                    Some(Ok(Message::Ping(_))) | Some(Ok(Message::Pong(_))) => {
-                        // get a ping/pong, ignore.  tungstenite will
-                        // send responses automatically.
-                        continue;
-                    },
-                    None |
-                    Some(Ok(Message::Close(_))) |
-                    Some(Err(WsError::AlreadyClosed)) |
-                    Some(Err(WsError::ConnectionClosed)) |
-                    Some(Err(WsError::Protocol(tungstenite::error::ProtocolError::ResetWithoutClosingHandshake)))
-                        => {
-                        debug!("websocket close from client: {:?}",cid);
-                        break;
-                    },
-                    Some(Err(WsError::Io(e))) => {
-                        // IO errors are considered fatal
-                        warn!("IO error (client: {:?}): {:?}", cid, e);
-                        break;
-                    }
-                    x => {
-                        // default condition on error is to close the client connection
-                        info!("unknown error (client: {:?}): {:?} (closing conn)", cid, x);
-                        break;
-                    }
-                };
-
-                // convert ws_next into proto_next
-                match nostr_msg {
-                    Ok(NostrMessage::EventMsg(ec)) => {
-                        // An EventCmd needs to be validated to be converted into an Event
-                        // handle each type of message
-                        let parsed : Result<Event> = Result::<Event>::from(ec);
-                        match parsed {
-                            Ok(e) => {
-                                let id_prefix:String = e.id.chars().take(8).collect();
-                                debug!("successfully parsed/validated event: {:?} from client: {:?}", id_prefix, cid);
-                                // Write this to the database.
-                                let submit_event = SubmittedEvent { event: e.clone(), notice_tx: notice_tx.clone() };
-                                event_tx.send(submit_event).await.ok();
-                                client_published_event_count += 1;
-                            },
-                            Err(_) => {
-                                info!("client {:?} sent an invalid event", cid);
-                                ws_stream.send(make_notice_message("event was invalid")).await.ok();
-                            }
-                        }
-                    },
-                    Ok(NostrMessage::SubMsg(s)) => {
-                        debug!("client {} requesting a subscription", cid);
-                        // subscription handling consists of:
-                        // * registering the subscription so future events can be matched
-                        // * making a channel to cancel to request later
-                        // * sending a request for a SQL query
-                        let (abandon_query_tx, abandon_query_rx) = oneshot::channel::<()>();
-                        match conn.subscribe(s.clone()) {
-                            Ok(()) => {
-                                // when we insert, if there was a previous query running with the same name, cancel it.
-                                if let Some(previous_query) = running_queries.insert(s.id.to_owned(), abandon_query_tx) {
-                                    previous_query.send(()).ok();
-                                }
-                                // start a database query
-                                db::db_query(s, cid.to_owned(), pool.clone(), query_tx.clone(), abandon_query_rx).await;
-                            },
-                            Err(e) => {
-                                info!("Subscription error: {}", e);
-                                ws_stream.send(make_notice_message(&e.to_string())).await.ok();
-                            }
-                        }
-                    },
-                    Ok(NostrMessage::CloseMsg(cc)) => {
-                        // closing a request simply removes the subscription.
-                        let parsed : Result<Close> = Result::<Close>::from(cc);
-                        match parsed {
-                            Ok(c) => {
-                                // check if a query is currently
-                                // running, and remove it if so.
-                                let stop_tx = running_queries.remove(&c.id);
-                                if let Some(tx) = stop_tx {
-                                    tx.send(()).ok();
-                                }
-                                // stop checking new events against
-                                // the subscription
-                                conn.unsubscribe(c);
-                            },
-                            Err(_) => {
-                                info!("invalid command ignored");
-                                ws_stream.send(make_notice_message("could not parse command")).await.ok();
-                            }
-                        }
-                    },
-                    Err(Error::ConnError) => {
-                        debug!("got connection close/error, disconnecting client: {:?}",cid);
-                        break;
-                    }
-                    Err(Error::EventMaxLengthError(s)) => {
-                        info!("client {:?} sent event larger ({} bytes) than max size", cid, s);
-                        ws_stream.send(make_notice_message("event exceeded max size")).await.ok();
-                    },
-                    Err(Error::ProtoParseError) => {
-                        info!("client {:?} sent event that could not be parsed", cid);
-                        ws_stream.send(make_notice_message("could not parse command")).await.ok();
-                    },
-                    Err(e) => {
-                        info!("got non-fatal error from client: {:?}, error: {:?}", cid, e);
-                    },
-                }
-            },
-        }
+    // update with database location from args, if provided
+    if let Some(db_dir) = db_dir_arg {
+        settings.database.data_directory = db_dir;
     }
-    // connection cleanup - ensure any still running queries are terminated.
-    for (_, stop_tx) in running_queries.into_iter() {
-        stop_tx.send(()).ok();
-    }
-    info!(
-        "stopping connection for client: {:?} (client sent {} event(s), received {})",
-        cid, client_published_event_count, client_received_event_count
-    );
+    // we should have a 'control plane' channel to monitor and bump
+    // the server.  this will let us do stuff like clear the database,
+    // shutdown, etc.; for now all this does is initiate shutdown if
+    // `()` is sent.  This will change in the future, this is just a
+    // stopgap to shutdown the relay when it is used as a library.
+    let (_, ctrl_rx): (MpscSender<()>, MpscReceiver<()>) = syncmpsc::channel();
+    // run this in a new thread
+    let handle = thread::spawn(move || {
+        let _svr = start_server(&settings, ctrl_rx);
+    });
+    // block on nostr thread to finish.
+    handle.join().unwrap();
 }

src/nauthz.rs

@@ -0,0 +1,111 @@
+use crate::error::{Error, Result};
+use crate::{event::Event, nip05::Nip05Name};
+use nauthz_grpc::authorization_client::AuthorizationClient;
+use nauthz_grpc::event::TagEntry;
+use nauthz_grpc::{Decision, Event as GrpcEvent, EventReply, EventRequest};
+use tracing::{info, warn};
+
+pub mod nauthz_grpc {
+    tonic::include_proto!("nauthz");
+}
+
+// A decision for the DB to act upon
+pub trait AuthzDecision: Send + Sync {
+    fn permitted(&self) -> bool;
+    fn message(&self) -> Option<String>;
+}
+
+impl AuthzDecision for EventReply {
+    fn permitted(&self) -> bool {
+        self.decision == Decision::Permit as i32
+    }
+    fn message(&self) -> Option<String> {
+        self.message.clone()
+    }
+}
+
+// A connection to an event admission GRPC server
+pub struct EventAuthzService {
+    server_addr: String,
+    conn: Option<AuthorizationClient<tonic::transport::Channel>>,
+}
+
+// conversion of Nip05Names into GRPC type
+impl std::convert::From<Nip05Name> for nauthz_grpc::event_request::Nip05Name {
+    fn from(value: Nip05Name) -> Self {
+        nauthz_grpc::event_request::Nip05Name {
+            local: value.local.clone(),
+            domain: value.domain,
+        }
+    }
+}
+
+// conversion of event tags into gprc struct
+fn tags_to_protobuf(tags: &[Vec<String>]) -> Vec<TagEntry> {
+    tags.iter()
+        .map(|x| TagEntry { values: x.clone() })
+        .collect()
+}
+
+impl EventAuthzService {
+    pub async fn connect(server_addr: &str) -> EventAuthzService {
+        let mut eas = EventAuthzService {
+            server_addr: server_addr.to_string(),
+            conn: None,
+        };
+        eas.ready_connection().await;
+        eas
+    }
+
+    pub async fn ready_connection(&mut self) {
+        if self.conn.is_none() {
+            let client = AuthorizationClient::connect(self.server_addr.to_string()).await;
+            if let Err(ref msg) = client {
+                warn!("could not connect to nostr authz GRPC server: {:?}", msg);
+            } else {
+                info!("connected to nostr authorization GRPC server");
+            }
+            self.conn = client.ok();
+        }
+    }
+
+    pub async fn admit_event(
+        &mut self,
+        event: &Event,
+        ip: &str,
+        origin: Option<String>,
+        user_agent: Option<String>,
+        nip05: Option<Nip05Name>,
+        auth_pubkey: Option<Vec<u8>>,
+    ) -> Result<Box<dyn AuthzDecision>> {
+        self.ready_connection().await;
+        let id_blob = hex::decode(&event.id)?;
+        let pubkey_blob = hex::decode(&event.pubkey)?;
+        let sig_blob = hex::decode(&event.sig)?;
+        if let Some(ref mut c) = self.conn {
+            let gevent = GrpcEvent {
+                id: id_blob,
+                pubkey: pubkey_blob,
+                sig: sig_blob,
+                created_at: event.created_at,
+                kind: event.kind,
+                content: event.content.clone(),
+                tags: tags_to_protobuf(&event.tags),
+            };
+            let svr_res = c
+                .event_admit(EventRequest {
+                    event: Some(gevent),
+                    ip_addr: Some(ip.to_string()),
+                    origin,
+                    user_agent,
+                    auth_pubkey,
+                    nip05: nip05.map(nauthz_grpc::event_request::Nip05Name::from),
+                })
+                .await?;
+            let reply = svr_res.into_inner();
+            Ok(Box::new(reply))
+        } else {
+            Err(Error::AuthzError)
+        }
+    }
+}

src/nip05.rs

@@ -4,33 +4,31 @@
 //! address with their public key, in metadata events.  This module
 //! consumes a stream of metadata events, and keeps a database table
 //! updated with the current NIP-05 verification status.
-use crate::config::SETTINGS;
-use crate::db;
+use crate::config::VerifiedUsers;
 use crate::error::{Error, Result};
 use crate::event::Event;
-use crate::utils::unix_time;
+use crate::repo::NostrRepo;
 use hyper::body::HttpBody;
 use hyper::client::connect::HttpConnector;
 use hyper::Client;
-use hyper_tls::HttpsConnector;
-use log::*;
-use rand::Rng;
-use rusqlite::params;
+use hyper_rustls::HttpsConnector;
+use std::sync::Arc;
 use std::time::Duration;
 use std::time::Instant;
 use std::time::SystemTime;
 use tokio::time::Interval;
+use tracing::{debug, info, warn};
 
 /// NIP-05 verifier state
 pub struct Verifier {
+    /// Repository for saving/retrieving events and records
+    repo: Arc<dyn NostrRepo>,
     /// Metadata events for us to inspect
     metadata_rx: tokio::sync::broadcast::Receiver<Event>,
     /// Newly validated events get written and then broadcast on this channel to subscribers
     event_tx: tokio::sync::broadcast::Sender<Event>,
-    /// SQLite read query pool
-    read_pool: db::SqlitePool,
-    /// SQLite write query pool
-    write_pool: db::SqlitePool,
+    /// Settings
+    settings: crate::config::Settings,
     /// HTTP client
     client: hyper::Client<HttpsConnector<HttpConnector>, hyper::Body>,
     /// After all accounts are updated, wait this long before checking again.
@@ -42,14 +40,15 @@ pub struct Verifier {
 }
 
 /// A NIP-05 identifier is a local part and domain.
-#[derive(PartialEq, Debug, Clone)]
+#[derive(PartialEq, Eq, Debug, Clone)]
 pub struct Nip05Name {
-    local: String,
-    domain: String,
+    pub local: String,
+    pub domain: String,
 }
 
 impl Nip05Name {
     /// Does this name represent the entire domain?
+    #[must_use]
     pub fn is_domain_only(&self) -> bool {
         self.local == "_"
     }
@@ -71,9 +70,7 @@ impl std::convert::TryFrom<&str> for Nip05Name {
     fn try_from(inet: &str) -> Result<Self, Self::Error> {
         // break full name at the @ boundary.
         let components: Vec<&str> = inet.split('@').collect();
-        if components.len() != 2 {
-            Err(Error::CustomError("too many/few components".to_owned()))
-        } else {
+        if components.len() == 2 {
             // check if local name is valid
             let local = components[0];
             let domain = components[1];
@@ -99,6 +96,8 @@ impl std::convert::TryFrom<&str> for Nip05Name {
                     "invalid character in local part".to_owned(),
                 ))
             }
+        } else {
+            Err(Error::CustomError("too many/few components".to_owned()))
         }
     }
 }
@@ -109,54 +108,37 @@ impl std::fmt::Display for Nip05Name {
     }
 }
 
-// Current time, with a slight foward jitter in seconds
-fn now_jitter(sec: u64) -> u64 {
-    // random time between now, and 10min in future.
-    let mut rng = rand::thread_rng();
-    let jitter_amount = rng.gen_range(0..sec);
-    let now = unix_time();
-    now.saturating_add(jitter_amount)
-}
-
 /// Check if the specified username and address are present and match in this response body
-fn body_contains_user(username: &str, address: &str, bytes: hyper::body::Bytes) -> Result<bool> {
+fn body_contains_user(username: &str, address: &str, bytes: &hyper::body::Bytes) -> Result<bool> {
     // convert the body into json
-    let body: serde_json::Value = serde_json::from_slice(&bytes)?;
+    let body: serde_json::Value = serde_json::from_slice(bytes)?;
     // ensure we have a names object.
     let names_map = body
         .as_object()
         .and_then(|x| x.get("names"))
-        .and_then(|x| x.as_object())
+        .and_then(serde_json::Value::as_object)
         .ok_or_else(|| Error::CustomError("not a map".to_owned()))?;
     // get the pubkey for the requested user
-    let check_name = names_map.get(username).and_then(|x| x.as_str());
+    let check_name = names_map.get(username).and_then(serde_json::Value::as_str);
     // ensure the address is a match
-    Ok(check_name.map(|x| x == address).unwrap_or(false))
+    Ok(check_name == Some(address))
 }
 
 impl Verifier {
     pub fn new(
+        repo: Arc<dyn NostrRepo>,
         metadata_rx: tokio::sync::broadcast::Receiver<Event>,
         event_tx: tokio::sync::broadcast::Sender<Event>,
+        settings: crate::config::Settings,
     ) -> Result<Self> {
         info!("creating NIP-05 verifier");
-        // build a database connection for reading and writing.
-        let write_pool = db::build_pool(
-            "nip05 writer",
-            rusqlite::OpenFlags::SQLITE_OPEN_READ_WRITE,
-            1,    // min conns
-            4,    // max conns
-            true, // wait for DB
-        );
-        let read_pool = db::build_pool(
-            "nip05 reader",
-            rusqlite::OpenFlags::SQLITE_OPEN_READ_ONLY,
-            1,    // min conns
-            8,    // max conns
-            true, // wait for DB
-        );
         // setup hyper client
-        let https = HttpsConnector::new();
+        let https = hyper_rustls::HttpsConnectorBuilder::new()
+            .with_native_roots()
+            .https_or_http()
+            .enable_http1()
+            .build();
+
         let client = Client::builder().build::<_, hyper::Body>(https);
 
         // After all accounts have been re-verified, don't check again
@@ -170,10 +152,10 @@ impl Verifier {
         // duration.
         let reverify_interval = tokio::time::interval(http_wait_duration);
         Ok(Verifier {
+            repo,
             metadata_rx,
             event_tx,
-            read_pool,
-            write_pool,
+            settings,
             client,
             wait_after_finish,
             http_wait_duration,
@@ -214,7 +196,11 @@ impl Verifier {
         pubkey: &str,
     ) -> Result<UserWebVerificationStatus> {
         // determine if this domain should be checked
-        if !is_domain_allowed(&nip.domain) {
+        if !is_domain_allowed(
+            &nip.domain,
+            &self.settings.verified_users.domain_whitelist,
+            &self.settings.verified_users.domain_blacklist,
+        ) {
             return Ok(UserWebVerificationStatus::DomainNotAllowed);
         }
         let url = nip
@@ -222,7 +208,7 @@ impl Verifier {
             .ok_or_else(|| Error::CustomError("invalid NIP-05 URL".to_owned()))?;
         let req = hyper::Request::builder()
             .method(hyper::Method::GET)
-            .uri(url)
+            .uri(url.clone())
             .header("Accept", "application/json")
             .header(
                 "User-Agent",
@@ -236,47 +222,88 @@ impl Verifier {
 
         let response_fut = self.client.request(req);
 
-        // HTTP request with timeout
-        match tokio::time::timeout(Duration::from_secs(5), response_fut).await {
-            Ok(response_res) => {
-                let response = response_res?;
-                // limit size of verification document to 1MB.
-                const MAX_ALLOWED_RESPONSE_SIZE: u64 = 1024 * 1024;
-                // determine content length from response
-                let response_content_length = match response.body().size_hint().upper() {
-                    Some(v) => v,
-                    None => MAX_ALLOWED_RESPONSE_SIZE + 1, // reject missing content length
-                };
-                // TODO: test how hyper handles the client providing an inaccurate content-length.
-                if response_content_length <= MAX_ALLOWED_RESPONSE_SIZE {
-                    let (parts, body) = response.into_parts();
-                    // TODO: consider redirects
-                    if parts.status == http::StatusCode::OK {
-                        // parse body, determine if the username / key / address is present
-                        let body_bytes = hyper::body::to_bytes(body).await?;
-                        let body_matches = body_contains_user(&nip.local, pubkey, body_bytes)?;
-                        if body_matches {
-                            return Ok(UserWebVerificationStatus::Verified);
-                        } else {
-                            // successful response, parsed as a nip-05
-                            // document, but this name/pubkey was not
-                            // present.
-                            return Ok(UserWebVerificationStatus::Unverified);
-                        }
-                    }
-                } else {
-                    info!(
-                        "content length missing or exceeded limits for account: {:?}",
-                        nip.to_string()
-                    );
-                }
-            }
-            Err(_) => {
-                info!("timeout verifying account {:?}", nip);
+        if let Ok(response_res) = tokio::time::timeout(Duration::from_secs(5), response_fut).await {
+            // limit size of verification document to 1MB.
+            const MAX_ALLOWED_RESPONSE_SIZE: u64 = 1024 * 1024;
+            let response = response_res?;
+            let status = response.status();
+
+            // Log non-2XX status codes
+            if !status.is_success() {
+                info!(
+                    "unexpected status code {} received for account {:?} at URL: {}",
+                    status,
+                    nip.to_string(),
+                    url
+                );
                 return Ok(UserWebVerificationStatus::Unknown);
             }
+
+            // determine content length from response
+            let response_content_length = match response.body().size_hint().upper() {
+                Some(v) => v,
+                None => {
+                    info!(
+                        "missing content length header for account {:?} at URL: {}",
+                        nip.to_string(),
+                        url
+                    );
+                    return Ok(UserWebVerificationStatus::Unknown);
+                }
+            };
+
+            if response_content_length > MAX_ALLOWED_RESPONSE_SIZE {
+                info!(
+                    "content length {} exceeded limit of {} bytes for account {:?} at URL: {}",
+                    response_content_length,
+                    MAX_ALLOWED_RESPONSE_SIZE,
+                    nip.to_string(),
+                    url
+                );
+                return Ok(UserWebVerificationStatus::Unknown);
+            }
+
+            let (parts, body) = response.into_parts();
+            // TODO: consider redirects
+            if parts.status == http::StatusCode::OK {
+                // parse body, determine if the username / key / address is present
+                let body_bytes = match hyper::body::to_bytes(body).await {
+                    Ok(bytes) => bytes,
+                    Err(e) => {
+                        info!(
+                            "failed to read response body for account {:?} at URL: {}: {:?}",
+                            nip.to_string(),
+                            url,
+                            e
+                        );
+                        return Ok(UserWebVerificationStatus::Unknown);
+                    }
+                };
+
+                match body_contains_user(&nip.local, pubkey, &body_bytes) {
+                    Ok(true) => Ok(UserWebVerificationStatus::Verified),
+                    Ok(false) => Ok(UserWebVerificationStatus::Unverified),
+                    Err(e) => {
+                        info!(
+                            "error parsing response body for account {:?}: {:?}",
+                            nip.to_string(),
+                            e
+                        );
+                        Ok(UserWebVerificationStatus::Unknown)
+                    }
+                }
+            } else {
+                info!(
+                    "unexpected status code {} for account {:?}",
+                    parts.status,
+                    nip.to_string()
+                );
+                Ok(UserWebVerificationStatus::Unknown)
+            }
+        } else {
+            info!("timeout verifying account {:?}", nip);
+            Ok(UserWebVerificationStatus::Unknown)
         }
-        Ok(UserWebVerificationStatus::Unknown)
     }
 
     /// Perform NIP-05 verifier tasks.
@@ -285,8 +312,15 @@ impl Verifier {
         // run a loop, restarting on failure
         loop {
             let res = self.run_internal().await;
-            if let Err(e) = res {
-                info!("error in verifier: {:?}", e);
+            match res {
+                Err(Error::ChannelClosed) => {
+                    // channel was closed, we are shutting down
+                    return;
+                }
+                Err(e) => {
+                    info!("error in verifier: {:?}", e);
+                }
+                _ => {}
             }
         }
     }
@@ -300,7 +334,7 @@ impl Verifier {
                         if let Some(naddr) = e.get_nip05_addr() {
                             info!("got metadata event for ({:?},{:?})", naddr.to_string() ,e.get_author_prefix());
                             // Process a new author, checking if they are verified:
-                            let check_verified = get_latest_user_verification(self.read_pool.get().expect("could not get connection"), &e.pubkey).await;
+                            let check_verified = self.repo.get_latest_user_verification(&e.pubkey).await;
                             // ensure the event we got is more recent than the one we have, otherwise we can ignore it.
                             if let Ok(last_check) = check_verified {
                                 if e.created_at <= last_check.event_created {
@@ -333,6 +367,7 @@ impl Verifier {
                     }
                     Err(tokio::sync::broadcast::error::RecvError::Closed) => {
                         info!("metadata broadcast channel closed");
+                        return Err(Error::ChannelClosed);
                     }
                 }
             },
@@ -347,15 +382,11 @@ impl Verifier {
 
     /// Reverify the oldest user verification record.
     async fn do_reverify(&mut self) -> Result<()> {
-        let reverify_setting;
-        let max_failures;
-        {
-            // this block prevents a read handle to settings being
-            // captured by the async DB call (guard is not Send)
-            let settings = SETTINGS.read().unwrap();
-            reverify_setting = settings.verified_users.verify_update_frequency_duration;
-            max_failures = settings.verified_users.max_consecutive_failures;
-        }
+        let reverify_setting = self
+            .settings
+            .verified_users
+            .verify_update_frequency_duration;
+        let max_failures = self.settings.verified_users.max_consecutive_failures;
         // get from settings, but default to 6hrs between re-checking an account
         let reverify_dur = reverify_setting.unwrap_or_else(|| Duration::from_secs(60 * 60 * 6));
         // find all verification records that have success or failure OLDER than the reverify_dur.
@@ -365,7 +396,7 @@ impl Verifier {
             .duration_since(SystemTime::UNIX_EPOCH)
             .map(|x| x.as_secs())
             .unwrap_or(0);
-        let vr = get_oldest_user_verification(self.read_pool.get()?, earliest_epoch).await;
+        let vr = self.repo.get_oldest_user_verification(earliest_epoch).await;
         match vr {
             Ok(ref v) => {
                 let new_status = self.get_web_verification(&v.name, &v.address).await;
@@ -373,8 +404,8 @@ impl Verifier {
                     UserWebVerificationStatus::Verified => {
                         // freshly verified account, update the
                         // timestamp.
-                        self.update_verification_record(self.write_pool.get()?, v)
-                            .await?;
+                        self.repo.update_verification_timestamp(v.rowid).await?;
+                        info!("verification updated for {}", v.to_string());
                     }
                     UserWebVerificationStatus::DomainNotAllowed
                     | UserWebVerificationStatus::Unknown => {
@@ -389,23 +420,25 @@ impl Verifier {
                                 "giving up on verifying {:?} after {} failures",
                                 v.name, v.failure_count
                             );
-                            self.delete_verification_record(self.write_pool.get()?, v)
-                                .await?;
+                            self.repo.delete_verification(v.rowid).await?;
                         } else {
                             // record normal failure, incrementing failure count
-                            self.fail_verification_record(self.write_pool.get()?, v)
-                                .await?;
+                            info!("verification failed for {}", v.to_string());
+                            self.repo.fail_verification(v.rowid).await?;
                         }
                     }
                     UserWebVerificationStatus::Unverified => {
                         // domain has removed the verification, drop
                         // the record on our side.
-                        self.delete_verification_record(self.write_pool.get()?, v)
-                            .await?;
+                        info!("verification rescinded for {}", v.to_string());
+                        self.repo.delete_verification(v.rowid).await?;
                     }
                 }
             }
-            Err(Error::SqlError(rusqlite::Error::QueryReturnedNoRows)) => {
+            Err(
+                Error::SqlError(rusqlite::Error::QueryReturnedNoRows)
+                | Error::SqlxError(sqlx::Error::RowNotFound),
+            ) => {
                 // No users need verification.  Reset the interval to
                 // the next verification attempt.
                 let start = tokio::time::Instant::now() + self.wait_after_finish;
@@ -421,80 +454,6 @@ impl Verifier {
         Ok(())
     }
 
-    /// Reset the verification timestamp on a VerificationRecord
-    pub async fn update_verification_record(
-        &mut self,
-        mut conn: db::PooledConnection,
-        vr: &VerificationRecord,
-    ) -> Result<()> {
-        let vr_id = vr.rowid;
-        let vr_str = vr.to_string();
-        tokio::task::spawn_blocking(move || {
-            // add some jitter to the verification to prevent everything from stacking up together.
-            let verif_time = now_jitter(600);
-            let tx = conn.transaction()?;
-            {
-                // update verification time and reset any failure count
-                let query =
-                    "UPDATE user_verification SET verified_at=?, failure_count=0 WHERE id=?";
-                let mut stmt = tx.prepare(query)?;
-                stmt.execute(params![verif_time, vr_id])?;
-            }
-            tx.commit()?;
-            info!("verification updated for {}", vr_str);
-            let ok: Result<()> = Ok(());
-            ok
-        })
-        .await?
-    }
-    /// Reset the failure timestamp on a VerificationRecord
-    pub async fn fail_verification_record(
-        &mut self,
-        mut conn: db::PooledConnection,
-        vr: &VerificationRecord,
-    ) -> Result<()> {
-        let vr_id = vr.rowid;
-        let vr_str = vr.to_string();
-        let fail_count = vr.failure_count.saturating_add(1);
-        tokio::task::spawn_blocking(move || {
-            // add some jitter to the verification to prevent everything from stacking up together.
-            let fail_time = now_jitter(600);
-            let tx = conn.transaction()?;
-            {
-                let query = "UPDATE user_verification SET failed_at=?, failure_count=? WHERE id=?";
-                let mut stmt = tx.prepare(query)?;
-                stmt.execute(params![fail_time, fail_count, vr_id])?;
-            }
-            tx.commit()?;
-            info!("verification failed for {}", vr_str);
-            let ok: Result<()> = Ok(());
-            ok
-        })
-        .await?
-    }
-    /// Delete a VerificationRecord that is no longer valid
-    pub async fn delete_verification_record(
-        &mut self,
-        mut conn: db::PooledConnection,
-        vr: &VerificationRecord,
-    ) -> Result<()> {
-        let vr_id = vr.rowid;
-        let vr_str = vr.to_string();
-        tokio::task::spawn_blocking(move || {
-            let tx = conn.transaction()?;
-            {
-                let query = "DELETE FROM user_verification WHERE id=?;";
-                let mut stmt = tx.prepare(query)?;
-                stmt.execute(params![vr_id])?;
-            }
-            tx.commit()?;
-            info!("verification rescinded for {}", vr_str);
-            let ok: Result<()> = Ok(());
-            ok
-        })
-        .await?
-    }
-
     /// Persist an event, create a verification record, and broadcast.
     // TODO: have more event-writing logic handled in the db module.
     // Right now, these events avoid the rate limit.  That is
@@ -506,17 +465,13 @@ impl Verifier {
         let start = Instant::now();
         // we should only do this if we are enabled.  if we are
         // disabled/passive, the event has already been persisted.
-        let should_write_event;
-        {
-            let settings = SETTINGS.read().unwrap();
-            should_write_event = settings.verified_users.is_enabled()
-        }
+        let should_write_event = self.settings.verified_users.is_enabled();
         if should_write_event {
-            match db::write_event(&mut self.write_pool.get()?, event) {
+            match self.repo.write_event(event).await {
                 Ok(updated) => {
                     if updated != 0 {
                         info!(
-                            "persisted event: {:?} in {:?}",
+                            "persisted event (new verified pubkey): {:?} in {:?}",
                             event.get_event_id_prefix(),
                             start.elapsed()
                         );
@@ -532,13 +487,15 @@ impl Verifier {
             }
         }
         // write the verification record
-        save_verification_record(self.write_pool.get()?, event, name).await?;
+        self.repo
+            .create_verification_record(&event.id, name)
+            .await?;
         Ok(())
     }
 }
 
 /// Result of checking user's verification status against DNS/HTTP.
-#[derive(PartialEq, Debug, Clone)]
+#[derive(PartialEq, Eq, Debug, Clone)]
 pub enum UserWebVerificationStatus {
     Verified,         // user is verified, as of now.
     DomainNotAllowed, // domain blacklist or whitelist denied us from attempting a verification
@@ -547,7 +504,7 @@ pub enum UserWebVerificationStatus {
 }
 
 /// A NIP-05 verification record.
-#[derive(PartialEq, Debug, Clone)]
+#[derive(PartialEq, Eq, Debug, Clone)]
 // Basic information for a verification event.  Gives us all we need to assert a NIP-05 address is good.
 pub struct VerificationRecord {
     pub rowid: u64,                // database row for this verification event
@@ -562,15 +519,19 @@ pub struct VerificationRecord {
 
 /// Check with settings to determine if a given domain is allowed to
 /// publish.
-pub fn is_domain_allowed(domain: &str) -> bool {
-    let settings = SETTINGS.read().unwrap();
+#[must_use]
+pub fn is_domain_allowed(
+    domain: &str,
+    whitelist: &Option<Vec<String>>,
+    blacklist: &Option<Vec<String>>,
+) -> bool {
     // if there is a whitelist, domain must be present in it.
-    if let Some(wl) = &settings.verified_users.domain_whitelist {
+    if let Some(wl) = whitelist {
         // workaround for Vec contains not accepting &str
         return wl.iter().any(|x| x == domain);
     }
     // otherwise, check that user is not in the blacklist
-    if let Some(bl) = &settings.verified_users.domain_blacklist {
+    if let Some(bl) = blacklist {
         return !bl.iter().any(|x| x == domain);
     }
     true
@@ -579,17 +540,22 @@ pub fn is_domain_allowed(domain: &str) -> bool {
 impl VerificationRecord {
     /// Check if the record is recent enough to be considered valid,
     /// and the domain is allowed.
-    pub fn is_valid(&self) -> bool {
-        let settings = SETTINGS.read().unwrap();
+    #[must_use]
+    pub fn is_valid(&self, verified_users_settings: &VerifiedUsers) -> bool {
+        //let settings = SETTINGS.read().unwrap();
         // how long a verification record is good for
-        let nip05_expiration = &settings.verified_users.verify_expiration_duration;
+        let nip05_expiration = &verified_users_settings.verify_expiration_duration;
         if let Some(e) = nip05_expiration {
             if !self.is_current(e) {
                 return false;
             }
         }
         // check domains
-        is_domain_allowed(&self.name.domain)
+        is_domain_allowed(
+            &self.name.domain,
+            &verified_users_settings.domain_whitelist,
+            &verified_users_settings.domain_blacklist,
+        )
     }
 
     /// Check if this record has been validated since the given
@@ -622,132 +588,6 @@ impl std::fmt::Display for VerificationRecord {
     }
 }
 
-/// Create a new verification record based on an event
-pub async fn save_verification_record(
-    mut conn: db::PooledConnection,
-    event: &Event,
-    name: &str,
-) -> Result<()> {
-    let e = hex::decode(&event.id).ok();
-    let n = name.to_owned();
-    let a_prefix = event.get_author_prefix();
-    tokio::task::spawn_blocking(move || {
-        let tx = conn.transaction()?;
-        {
-            // if we create a /new/ one, we should get rid of any old ones.  or group the new ones by name and only consider the latest.
-            let query = "INSERT INTO user_verification (metadata_event, name, verified_at) VALUES ((SELECT id from event WHERE event_hash=?), ?, strftime('%s','now'));";
-            let mut stmt = tx.prepare(query)?;
-            stmt.execute(params![e, n])?;
-            // get the row ID
-            let v_id = tx.last_insert_rowid();
-            // delete everything else by this name
-            let del_query = "DELETE FROM user_verification WHERE name = ? AND id != ?;";
-            let mut del_stmt = tx.prepare(del_query)?;
-            let count = del_stmt.execute(params![n,v_id])?;
-            if count > 0 {
-                info!("removed {} old verification records for ({:?},{:?})", count, n, a_prefix);
-            }
-        }
-        tx.commit()?;
-        info!("saved new verification record for ({:?},{:?})", n, a_prefix);
-        let ok: Result<()> = Ok(());
-        ok
-    }).await?
-}
-
-/// Retrieve the most recent verification record for a given pubkey (async).
-pub async fn get_latest_user_verification(
-    conn: db::PooledConnection,
-    pubkey: &str,
-) -> Result<VerificationRecord> {
-    let p = pubkey.to_owned();
-    tokio::task::spawn_blocking(move || query_latest_user_verification(conn, p)).await?
-}
-
-/// Query database for the latest verification record for a given pubkey.
-pub fn query_latest_user_verification(
-    mut conn: db::PooledConnection,
-    pubkey: String,
-) -> Result<VerificationRecord> {
-    let tx = conn.transaction()?;
-    let query = "SELECT v.id, v.name, e.event_hash, e.created_at, v.verified_at, v.failed_at, v.failure_count FROM user_verification v LEFT JOIN event e ON e.id=v.metadata_event WHERE e.author=? ORDER BY e.created_at DESC, v.verified_at DESC, v.failed_at DESC LIMIT 1;";
-    let mut stmt = tx.prepare_cached(query)?;
-    let fields = stmt.query_row(params![hex::decode(&pubkey).ok()], |r| {
-        let rowid: u64 = r.get(0)?;
-        let rowname: String = r.get(1)?;
-        let eventid: Vec<u8> = r.get(2)?;
-        let created_at: u64 = r.get(3)?;
-        // create a tuple since we can't throw non-rusqlite errors in this closure
-        Ok((
-            rowid,
-            rowname,
-            eventid,
-            created_at,
-            r.get(4).ok(),
-            r.get(5).ok(),
-            r.get(6)?,
-        ))
-    })?;
-    Ok(VerificationRecord {
-        rowid: fields.0,
-        name: Nip05Name::try_from(&fields.1[..])?,
-        address: pubkey,
-        event: hex::encode(fields.2),
-        event_created: fields.3,
-        last_success: fields.4,
-        last_failure: fields.5,
-        failure_count: fields.6,
-    })
-}
-
-/// Retrieve the oldest user verification (async)
-pub async fn get_oldest_user_verification(
-    conn: db::PooledConnection,
-    earliest: u64,
-) -> Result<VerificationRecord> {
-    let res =
-        tokio::task::spawn_blocking(move || query_oldest_user_verification(conn, earliest)).await?;
-    res
-}
-
-pub fn query_oldest_user_verification(
-    mut conn: db::PooledConnection,
-    earliest: u64,
-) -> Result<VerificationRecord> {
-    let tx = conn.transaction()?;
-    let query = "SELECT v.id, v.name, e.event_hash, e.author, e.created_at, v.verified_at, v.failed_at, v.failure_count FROM user_verification v LEFT JOIN event e ON e.id=v.metadata_event WHERE (v.verified_at < ? OR v.verified_at IS NULL) AND (v.failed_at < ? OR v.failed_at IS NULL) ORDER BY v.verified_at ASC, v.failed_at ASC LIMIT 1;";
-    let mut stmt = tx.prepare_cached(query)?;
-    let fields = stmt.query_row(params![earliest, earliest], |r| {
-        let rowid: u64 = r.get(0)?;
-        let rowname: String = r.get(1)?;
-        let eventid: Vec<u8> = r.get(2)?;
-        let pubkey: Vec<u8> = r.get(3)?;
-        let created_at: u64 = r.get(4)?;
-        // create a tuple since we can't throw non-rusqlite errors in this closure
-        Ok((
-            rowid,
-            rowname,
-            eventid,
-            pubkey,
-            created_at,
-            r.get(5).ok(),
-            r.get(6).ok(),
-            r.get(7)?,
-        ))
-    })?;
-    let vr = VerificationRecord {
-        rowid: fields.0,
-        name: Nip05Name::try_from(&fields.1[..])?,
-        address: hex::encode(fields.3),
-        event: hex::encode(fields.2),
-        event_created: fields.4,
-        last_success: fields.5,
-        last_failure: fields.6,
-        failure_count: fields.7,
-    };
-    Ok(vr)
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -756,7 +596,7 @@ mod tests {
     fn local_from_inet() {
         let addr = "bob@example.com";
         let parsed = Nip05Name::try_from(addr);
-        assert!(!parsed.is_err());
+        assert!(parsed.is_ok());
         let v = parsed.unwrap();
         assert_eq!(v.local, "bob");
         assert_eq!(v.domain, "example.com");

src/notice.rs

@@ -0,0 +1,101 @@
+pub enum EventResultStatus {
+    Saved,
+    Duplicate,
+    Invalid,
+    Blocked,
+    RateLimited,
+    Error,
+    Restricted,
+}
+
+pub struct EventResult {
+    pub id: String,
+    pub msg: String,
+    pub status: EventResultStatus,
+}
+
+pub enum Notice {
+    Message(String),
+    EventResult(EventResult),
+    AuthChallenge(String),
+}
+
+impl EventResultStatus {
+    #[must_use]
+    pub fn to_bool(&self) -> bool {
+        match self {
+            Self::Duplicate | Self::Saved => true,
+            Self::Invalid | Self::Blocked | Self::RateLimited | Self::Error | Self::Restricted => {
+                false
+            }
+        }
+    }
+
+    #[must_use]
+    pub fn prefix(&self) -> &'static str {
+        match self {
+            Self::Saved => "saved",
+            Self::Duplicate => "duplicate",
+            Self::Invalid => "invalid",
+            Self::Blocked => "blocked",
+            Self::RateLimited => "rate-limited",
+            Self::Error => "error",
+            Self::Restricted => "restricted",
+        }
+    }
+}
+
+impl Notice {
+    //pub fn err(err: error::Error, id: String) -> Notice {
+    //    Notice::err_msg(format!("{}", err), id)
+    //}
+
+    #[must_use]
+    pub fn message(msg: String) -> Notice {
+        Notice::Message(msg)
+    }
+
+    fn prefixed(id: String, msg: &str, status: EventResultStatus) -> Notice {
+        let msg = format!("{}: {}", status.prefix(), msg);
+        Notice::EventResult(EventResult { id, msg, status })
+    }
+
+    #[must_use]
+    pub fn invalid(id: String, msg: &str) -> Notice {
+        Notice::prefixed(id, msg, EventResultStatus::Invalid)
+    }
+
+    #[must_use]
+    pub fn blocked(id: String, msg: &str) -> Notice {
+        Notice::prefixed(id, msg, EventResultStatus::Blocked)
+    }
+
+    #[must_use]
+    pub fn rate_limited(id: String, msg: &str) -> Notice {
+        Notice::prefixed(id, msg, EventResultStatus::RateLimited)
+    }
+
+    #[must_use]
+    pub fn duplicate(id: String) -> Notice {
+        Notice::prefixed(id, "", EventResultStatus::Duplicate)
+    }
+
+    #[must_use]
+    pub fn error(id: String, msg: &str) -> Notice {
+        Notice::prefixed(id, msg, EventResultStatus::Error)
+    }
+
+    #[must_use]
+    pub fn restricted(id: String, msg: &str) -> Notice {
+        Notice::prefixed(id, msg, EventResultStatus::Restricted)
+    }
+
+    #[must_use]
+    pub fn saved(id: String) -> Notice {
+        Notice::EventResult(EventResult {
+            id,
+            msg: "".into(),
+            status: EventResultStatus::Saved,
+        })
+    }
+}

src/payment/cln_rest.rs

@@ -0,0 +1,137 @@
+use std::{fs, str::FromStr};
+
+use async_trait::async_trait;
+use cln_rpc::{
+    model::{
+        requests::InvoiceRequest,
+        responses::{InvoiceResponse, ListinvoicesInvoicesStatus, ListinvoicesResponse},
+    },
+    primitives::{Amount, AmountOrAny},
+};
+use config::ConfigError;
+use http::{header::CONTENT_TYPE, HeaderValue, Uri};
+use hyper::{client::HttpConnector, Client};
+use hyper_rustls::HttpsConnector;
+use nostr::Keys;
+use rand::random;
+
+use crate::{
+    config::Settings,
+    error::{Error, Result},
+};
+
+use super::{InvoiceInfo, InvoiceStatus, PaymentProcessor};
+
+#[derive(Clone)]
+pub struct ClnRestPaymentProcessor {
+    client: hyper::Client<HttpsConnector<HttpConnector>, hyper::Body>,
+    settings: Settings,
+    rune_header: HeaderValue,
+}
+
+impl ClnRestPaymentProcessor {
+    pub fn new(settings: &Settings) -> Result<Self> {
+        let rune_path = settings
+            .pay_to_relay
+            .rune_path
+            .clone()
+            .ok_or(ConfigError::NotFound("rune_path".to_string()))?;
+        let rune = String::from_utf8(fs::read(rune_path)?)
+            .map_err(|_| ConfigError::Message("Rune should be UTF8".to_string()))?;
+        let mut rune_header = HeaderValue::from_str(rune.trim())
+            .map_err(|_| ConfigError::Message("Invalid Rune header".to_string()))?;
+        rune_header.set_sensitive(true);
+
+        let https = hyper_rustls::HttpsConnectorBuilder::new()
+            .with_native_roots()
+            .https_only()
+            .enable_http1()
+            .build();
+        let client = Client::builder().build::<_, hyper::Body>(https);
+
+        Ok(Self {
+            client,
+            settings: settings.clone(),
+            rune_header,
+        })
+    }
+}
+
+#[async_trait]
+impl PaymentProcessor for ClnRestPaymentProcessor {
+    async fn get_invoice(&self, key: &Keys, amount: u64) -> Result<InvoiceInfo, Error> {
+        let random_number: u16 = random();
+        let memo = format!("{}: {}", random_number, key.public_key());
+
+        let body = InvoiceRequest {
+            cltv: None,
+            deschashonly: None,
+            expiry: None,
+            preimage: None,
+            exposeprivatechannels: None,
+            fallbacks: None,
+            amount_msat: AmountOrAny::Amount(Amount::from_sat(amount)),
+            description: memo.clone(),
+            label: "Nostr".to_string(),
+        };
+        let uri = Uri::from_str(&format!(
+            "{}/v1/invoice",
+            &self.settings.pay_to_relay.node_url
+        ))
+        .map_err(|_| ConfigError::Message("Bad node URL".to_string()))?;
+
+        let req = hyper::Request::builder()
+            .method(hyper::Method::POST)
+            .uri(uri)
+            .header(CONTENT_TYPE, HeaderValue::from_static("application/json"))
+            .header("Rune", self.rune_header.clone())
+            .body(hyper::Body::from(serde_json::to_string(&body)?))
+            .expect("request builder");
+
+        let res = self.client.request(req).await?;
+
+        let body = hyper::body::to_bytes(res.into_body()).await?;
+        let invoice_response: InvoiceResponse = serde_json::from_slice(&body)?;
+
+        Ok(InvoiceInfo {
+            pubkey: key.public_key().to_string(),
+            payment_hash: invoice_response.payment_hash.to_string(),
+            bolt11: invoice_response.bolt11,
+            amount,
+            memo,
+            status: InvoiceStatus::Unpaid,
+            confirmed_at: None,
+        })
+    }
+
+    async fn check_invoice(&self, payment_hash: &str) -> Result<InvoiceStatus, Error> {
+        let uri = Uri::from_str(&format!(
+            "{}/v1/listinvoices?payment_hash={}",
+            &self.settings.pay_to_relay.node_url, payment_hash
+        ))
+        .map_err(|_| ConfigError::Message("Bad node URL".to_string()))?;
+
+        let req = hyper::Request::builder()
+            .method(hyper::Method::POST)
+            .uri(uri)
+            .header(CONTENT_TYPE, HeaderValue::from_static("application/json"))
+            .header("Rune", self.rune_header.clone())
+            .body(hyper::Body::empty())
+            .expect("request builder");
+
+        let res = self.client.request(req).await?;
+
+        let body = hyper::body::to_bytes(res.into_body()).await?;
+        let invoice_response: ListinvoicesResponse = serde_json::from_slice(&body)?;
+        let invoice = invoice_response
+            .invoices
+            .first()
+            .ok_or(Error::CustomError("Invoice not found".to_string()))?;
+        let status = match invoice.status {
+            ListinvoicesInvoicesStatus::PAID => InvoiceStatus::Paid,
+            ListinvoicesInvoicesStatus::UNPAID => InvoiceStatus::Unpaid,
+            ListinvoicesInvoicesStatus::EXPIRED => InvoiceStatus::Expired,
+        };
+        Ok(status)
+    }
+}

src/payment/lnbits.rs

@@ -0,0 +1,176 @@
+//! LNBits payment processor
+use http::Uri;
+use hyper::client::connect::HttpConnector;
+use hyper::Client;
+use hyper_rustls::HttpsConnector;
+use nostr::Keys;
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+
+use async_trait::async_trait;
+use rand::Rng;
+
+use std::str::FromStr;
+use url::Url;
+
+use crate::{config::Settings, error::Error};
+
+use super::{InvoiceInfo, InvoiceStatus, PaymentProcessor};
+
+const APIPATH: &str = "/api/v1/payments/";
+
+/// Info LNBits expects in create invoice request
+#[derive(Serialize, Deserialize, Debug)]
+pub struct LNBitsCreateInvoice {
+    out: bool,
+    amount: u64,
+    memo: String,
+    webhook: String,
+    unit: String,
+    internal: bool,
+    expiry: u64,
+}
+
+/// Invoice response for LN bits
+#[derive(Debug, Serialize, Deserialize)]
+pub struct LNBitsCreateInvoiceResponse {
+    payment_hash: String,
+    payment_request: String,
+}
+
+/// LNBits call back response
+/// Used when an invoice is paid
+/// lnbits to post the status change to relay
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct LNBitsCallback {
+    pub checking_id: String,
+    pub pending: bool,
+    pub amount: u64,
+    pub memo: String,
+    pub time: u64,
+    pub bolt11: String,
+    pub preimage: String,
+    pub payment_hash: String,
+    pub wallet_id: String,
+    pub webhook: String,
+    pub webhook_status: Option<String>,
+}
+
+/// LN Bits repose for check invoice endpoint
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct LNBitsCheckInvoiceResponse {
+    paid: bool,
+}
+
+#[derive(Clone)]
+pub struct LNBitsPaymentProcessor {
+    /// HTTP client
+    client: hyper::Client<HttpsConnector<HttpConnector>, hyper::Body>,
+    settings: Settings,
+}
+
+impl LNBitsPaymentProcessor {
+    pub fn new(settings: &Settings) -> Self {
+        // setup hyper client
+        let https = hyper_rustls::HttpsConnectorBuilder::new()
+            .with_native_roots()
+            .https_only()
+            .enable_http1()
+            .build();
+        let client = Client::builder().build::<_, hyper::Body>(https);
+
+        Self {
+            client,
+            settings: settings.clone(),
+        }
+    }
+}
+
+#[async_trait]
+impl PaymentProcessor for LNBitsPaymentProcessor {
+    /// Calls LNBits api to ger new invoice
+    async fn get_invoice(&self, key: &Keys, amount: u64) -> Result<InvoiceInfo, Error> {
+        let random_number: u16 = rand::thread_rng().gen();
+        let memo = format!("{}: {}", random_number, key.public_key());
+
+        let callback_url = Url::parse(
+            &self
+                .settings
+                .info
+                .relay_url
+                .clone()
+                .unwrap()
+                .replace("ws", "http"),
+        )?
+        .join("lnbits")?;
+
+        let body = LNBitsCreateInvoice {
+            out: false,
+            amount,
+            memo: memo.clone(),
+            webhook: callback_url.to_string(),
+            unit: "sat".to_string(),
+            internal: false,
+            expiry: 3600,
+        };
+        let url = Url::parse(&self.settings.pay_to_relay.node_url)?.join(APIPATH)?;
+        let uri = Uri::from_str(url.as_str().strip_suffix('/').unwrap_or(url.as_str())).unwrap();
+
+        let req = hyper::Request::builder()
+            .method(hyper::Method::POST)
+            .uri(uri)
+            .header("X-Api-Key", &self.settings.pay_to_relay.api_secret)
+            .body(hyper::Body::from(serde_json::to_string(&body)?))
+            .expect("request builder");
+
+        let res = self.client.request(req).await?;
+
+        // Json to Struct of LNbits callback
+        let body = hyper::body::to_bytes(res.into_body()).await?;
+        let invoice_response: LNBitsCreateInvoiceResponse = serde_json::from_slice(&body)?;
+
+        Ok(InvoiceInfo {
+            pubkey: key.public_key().to_string(),
+            payment_hash: invoice_response.payment_hash,
+            bolt11: invoice_response.payment_request,
+            amount,
+            memo,
+            status: InvoiceStatus::Unpaid,
+            confirmed_at: None,
+        })
+    }
+
+    /// Calls LNBits Api to check the payment status of invoice
+    async fn check_invoice(&self, payment_hash: &str) -> Result<InvoiceStatus, Error> {
+        let url = Url::parse(&self.settings.pay_to_relay.node_url)?
+            .join(APIPATH)?
+            .join(payment_hash)?;
+        let uri = Uri::from_str(url.as_str()).unwrap();
+
+        let req = hyper::Request::builder()
+            .method(hyper::Method::GET)
+            .uri(uri)
+            .header("X-Api-Key", &self.settings.pay_to_relay.api_secret)
+            .body(hyper::Body::empty())
+            .expect("request builder");
+
+        let res = self.client.request(req).await?;
+        // Json to Struct of LNbits callback
+        let body = hyper::body::to_bytes(res.into_body()).await?;
+        let invoice_response: Value = serde_json::from_slice(&body)?;
+
+        let status = if let Ok(invoice_response) =
+            serde_json::from_value::<LNBitsCheckInvoiceResponse>(invoice_response)
+        {
+            if invoice_response.paid {
+                InvoiceStatus::Paid
+            } else {
+                InvoiceStatus::Unpaid
+            }
+        } else {
+            InvoiceStatus::Expired
+        };
+
+        Ok(status)
+    }
+}

src/payment/mod.rs

@@ -0,0 +1,280 @@
+use crate::error::{Error, Result};
+use crate::event::Event;
+use crate::payment::cln_rest::ClnRestPaymentProcessor;
+use crate::payment::lnbits::LNBitsPaymentProcessor;
+use crate::repo::NostrRepo;
+use serde::{Deserialize, Serialize};
+use std::sync::Arc;
+use tracing::{info, warn};
+
+use async_trait::async_trait;
+use nostr::key::{FromPkStr, FromSkStr};
+use nostr::{key::Keys, Event as NostrEvent, EventBuilder};
+
+pub mod cln_rest;
+pub mod lnbits;
+
+/// Payment handler
+pub struct Payment {
+    /// Repository for saving/retrieving events and events
+    repo: Arc<dyn NostrRepo>,
+    /// Newly validated events get written and then broadcast on this channel to subscribers
+    event_tx: tokio::sync::broadcast::Sender<Event>,
+    /// Payment message sender
+    payment_tx: tokio::sync::broadcast::Sender<PaymentMessage>,
+    /// Payment message receiver
+    payment_rx: tokio::sync::broadcast::Receiver<PaymentMessage>,
+    /// Settings
+    settings: crate::config::Settings,
+    // Nostr Keys
+    nostr_keys: Option<Keys>,
+    /// Payment Processor
+    processor: Arc<dyn PaymentProcessor>,
+}
+
+#[async_trait]
+pub trait PaymentProcessor: Send + Sync {
+    /// Get invoice from processor
+    async fn get_invoice(&self, keys: &Keys, amount: u64) -> Result<InvoiceInfo, Error>;
+    /// Check payment status of an invoice
+    async fn check_invoice(&self, payment_hash: &str) -> Result<InvoiceStatus, Error>;
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
+pub enum Processor {
+    LNBits,
+    ClnRest,
+}
+
+/// Possible states of an invoice
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, sqlx::Type)]
+#[sqlx(type_name = "status")]
+pub enum InvoiceStatus {
+    Unpaid,
+    Paid,
+    Expired,
+}
+
+impl std::fmt::Display for InvoiceStatus {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            InvoiceStatus::Paid => write!(f, "Paid"),
+            InvoiceStatus::Unpaid => write!(f, "Unpaid"),
+            InvoiceStatus::Expired => write!(f, "Expired"),
+        }
+    }
+}
+
+/// Invoice information
+#[derive(Debug, Clone)]
+pub struct InvoiceInfo {
+    pub pubkey: String,
+    pub payment_hash: String,
+    pub bolt11: String,
+    pub amount: u64,
+    pub status: InvoiceStatus,
+    pub memo: String,
+    pub confirmed_at: Option<u64>,
+}
+
+/// Message variants for the payment channel
+#[derive(Debug, Clone)]
+pub enum PaymentMessage {
+    /// New account
+    NewAccount(String),
+    /// Check account,
+    CheckAccount(String),
+    /// Account Admitted
+    AccountAdmitted(String),
+    /// Invoice generated
+    Invoice(String, InvoiceInfo),
+    /// Invoice call back
+    /// Payment hash is passed
+    // This may have to be changed to better support other processors
+    InvoicePaid(String),
+}
+
+impl Payment {
+    pub fn new(
+        repo: Arc<dyn NostrRepo>,
+        payment_tx: tokio::sync::broadcast::Sender<PaymentMessage>,
+        payment_rx: tokio::sync::broadcast::Receiver<PaymentMessage>,
+        event_tx: tokio::sync::broadcast::Sender<Event>,
+        settings: crate::config::Settings,
+    ) -> Result<Self> {
+        info!("Create payment handler");
+
+        // Create nostr key from sk string
+        let nostr_keys = if let Some(secret_key) = &settings.pay_to_relay.secret_key {
+            Some(Keys::from_sk_str(secret_key)?)
+        } else {
+            None
+        };
+
+        // Create processor kind defined in settings
+        let processor: Arc<dyn PaymentProcessor> = match &settings.pay_to_relay.processor {
+            Processor::LNBits => Arc::new(LNBitsPaymentProcessor::new(&settings)),
+            Processor::ClnRest => Arc::new(ClnRestPaymentProcessor::new(&settings)?),
+        };
+
+        Ok(Payment {
+            repo,
+            payment_tx,
+            payment_rx,
+            event_tx,
+            settings,
+            nostr_keys,
+            processor,
+        })
+    }
+
+    /// Perform Payment tasks
+    pub async fn run(&mut self) {
+        loop {
+            let res = self.run_internal().await;
+            if let Err(e) = res {
+                info!("error in payment: {:?}", e);
+            }
+        }
+    }
+
+    /// Internal select loop for preforming payment operations
+    async fn run_internal(&mut self) -> Result<()> {
+        tokio::select! {
+            m = self.payment_rx.recv() => {
+                match m {
+                    Ok(PaymentMessage::NewAccount(pubkey)) => {
+                        info!("payment event for {:?}", pubkey);
+                        // REVIEW: This will need to change for cost per event
+                        let amount = self.settings.pay_to_relay.admission_cost;
+                        let invoice_info = self.get_invoice_info(&pubkey, amount).await?;
+                        // TODO: should handle this error
+                        self.payment_tx.send(PaymentMessage::Invoice(pubkey, invoice_info)).ok();
+                    },
+                    // Gets the most recent unpaid invoice from database
+                    // Checks LNbits to verify if paid/unpaid
+                    Ok(PaymentMessage::CheckAccount(pubkey)) => {
+                        let keys = Keys::from_pk_str(&pubkey)?;
+
+                        if let Ok(Some(invoice_info)) = self.repo.get_unpaid_invoice(&keys).await {
+                            match self.check_invoice_status(&invoice_info.payment_hash).await? {
+                                InvoiceStatus::Paid => {
+                                    self.repo.admit_account(&keys, self.settings.pay_to_relay.admission_cost).await?;
+                                    self.payment_tx.send(PaymentMessage::AccountAdmitted(pubkey)).ok();
+                                }
+                                _ => {
+                                    self.payment_tx.send(PaymentMessage::Invoice(pubkey, invoice_info)).ok();
+                                }
+                            }
+                        } else {
+                        let amount = self.settings.pay_to_relay.admission_cost;
+                            let invoice_info = self.get_invoice_info(&pubkey, amount).await?;
+                            self.payment_tx.send(PaymentMessage::Invoice(pubkey, invoice_info)).ok();
+                        }
+                    }
+                    Ok(PaymentMessage::InvoicePaid(payment_hash)) => {
+                        if self.check_invoice_status(&payment_hash).await?.eq(&InvoiceStatus::Paid) {
+                            let pubkey = self.repo
+                                .update_invoice(&payment_hash, InvoiceStatus::Paid)
+                                .await?;
+
+                            let key = Keys::from_pk_str(&pubkey)?;
+                            self.repo.admit_account(&key, self.settings.pay_to_relay.admission_cost).await?;
+                        }
+                    }
+                    Ok(_) => {
+                        // For this variant nothing need to be done here
+                        // it is used by `server`
+                    }
+                    Err(err) => warn!("Payment RX: {err}")
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Sends Nostr DM to pubkey that requested invoice
+    /// Two events the terms followed by the bolt11 invoice
+    pub async fn send_admission_message(
+        &self,
+        pubkey: &str,
+        invoice_info: &InvoiceInfo,
+    ) -> Result<()> {
+        let nostr_keys = match &self.nostr_keys {
+            Some(key) => key,
+            None => return Err(Error::CustomError("Nostr key not defined".to_string())),
+        };
+
+        // Create Nostr key from pk
+        let key = Keys::from_pk_str(pubkey)?;
+
+        let pubkey = key.public_key();
+
+        // Event DM with terms of service
+        let message_event: NostrEvent = EventBuilder::new_encrypted_direct_msg(
+            nostr_keys,
+            pubkey,
+            &self.settings.pay_to_relay.terms_message,
+        )?
+        .to_event(nostr_keys)?;
+
+        // Event DM with invoice
+        let invoice_event: NostrEvent =
+            EventBuilder::new_encrypted_direct_msg(nostr_keys, pubkey, &invoice_info.bolt11)?
+                .to_event(nostr_keys)?;
+
+        // Persist DM events to DB
+        self.repo.write_event(&message_event.clone().into()).await?;
+        self.repo.write_event(&invoice_event.clone().into()).await?;
+
+        // Broadcast DM events
+        self.event_tx.send(message_event.clone().into()).ok();
+        self.event_tx.send(invoice_event.clone().into()).ok();
+
+        Ok(())
+    }
+
+    /// Get Invoice Info
+    /// If the has an active invoice that will be return
+    /// Otherwise a new invoice will be generated by the payment processor
+    pub async fn get_invoice_info(&self, pubkey: &str, amount: u64) -> Result<InvoiceInfo> {
+        // If user is already in DB this will be false
+        // This avoids recreating admission invoices
+        // I think it will continue to send DMs with the invoice
+        // If client continues to try and write to the relay (will be same invoice)
+        let key = Keys::from_pk_str(pubkey)?;
+        if !self.repo.create_account(&key).await? {
+            if let Ok(Some(invoice_info)) = self.repo.get_unpaid_invoice(&key).await {
+                return Ok(invoice_info);
+            }
+        }
+
+        let key = Keys::from_pk_str(pubkey)?;
+
+        let invoice_info = self.processor.get_invoice(&key, amount).await?;
+
+        // Persist invoice to DB
+        self.repo
+            .create_invoice_record(&key, invoice_info.clone())
+            .await?;
+
+        if self.settings.pay_to_relay.direct_message {
+            // Admission event invoice and terms to pubkey that is joining
+            self.send_admission_message(pubkey, &invoice_info).await?;
+        }
+
+        Ok(invoice_info)
+    }
+
+    /// Check paid status of invoice with LNbits
+    pub async fn check_invoice_status(&self, payment_hash: &str) -> Result<InvoiceStatus, Error> {
+        // Check base if passed expiry time
+        let status = self.processor.check_invoice(payment_hash).await?;
+        self.repo
+            .update_invoice(payment_hash, status.clone())
+            .await?;
+
+        Ok(status)
+    }
+}

src/repo/mod.rs

@@ -0,0 +1,98 @@
+use crate::db::QueryResult;
+use crate::error::Result;
+use crate::event::Event;
+use crate::nip05::VerificationRecord;
+use crate::payment::{InvoiceInfo, InvoiceStatus};
+use crate::subscription::Subscription;
+use crate::utils::unix_time;
+use async_trait::async_trait;
+use nostr::Keys;
+use rand::Rng;
+
+pub mod postgres;
+pub mod postgres_migration;
+pub mod sqlite;
+pub mod sqlite_migration;
+
+#[async_trait]
+pub trait NostrRepo: Send + Sync {
+    /// Start the repository (any initialization or maintenance tasks can be kicked off here)
+    async fn start(&self) -> Result<()>;
+
+    /// Run migrations and return current version
+    async fn migrate_up(&self) -> Result<usize>;
+
+    /// Persist event to database
+    async fn write_event(&self, e: &Event) -> Result<u64>;
+
+    /// Perform a database query using a subscription.
+    ///
+    /// The [`Subscription`] is converted into a SQL query.  Each result
+    /// is published on the `query_tx` channel as it is returned.  If a
+    /// message becomes available on the `abandon_query_rx` channel, the
+    /// query is immediately aborted.
+    async fn query_subscription(
+        &self,
+        sub: Subscription,
+        client_id: String,
+        query_tx: tokio::sync::mpsc::Sender<QueryResult>,
+        mut abandon_query_rx: tokio::sync::oneshot::Receiver<()>,
+    ) -> Result<()>;
+
+    /// Perform normal maintenance
+    async fn optimize_db(&self) -> Result<()>;
+
+    /// Create a new verification record connected to a specific event
+    async fn create_verification_record(&self, event_id: &str, name: &str) -> Result<()>;
+
+    /// Update verification timestamp
+    async fn update_verification_timestamp(&self, id: u64) -> Result<()>;
+
+    /// Update verification record as failed
+    async fn fail_verification(&self, id: u64) -> Result<()>;
+
+    /// Delete verification record
+    async fn delete_verification(&self, id: u64) -> Result<()>;
+
+    /// Get the latest verification record for a given pubkey.
+    async fn get_latest_user_verification(&self, pub_key: &str) -> Result<VerificationRecord>;
+
+    /// Get oldest verification before timestamp
+    async fn get_oldest_user_verification(&self, before: u64) -> Result<VerificationRecord>;
+
+    /// Create a new account
+    async fn create_account(&self, pubkey: &Keys) -> Result<bool>;
+
+    /// Admit an account
+    async fn admit_account(&self, pubkey: &Keys, admission_cost: u64) -> Result<()>;
+
+    /// Gets user balance if they are an admitted pubkey
+    async fn get_account_balance(&self, pubkey: &Keys) -> Result<(bool, u64)>;
+
+    /// Update account balance
+    async fn update_account_balance(
+        &self,
+        pub_key: &Keys,
+        positive: bool,
+        new_balance: u64,
+    ) -> Result<()>;
+
+    /// Create invoice record
+    async fn create_invoice_record(&self, pubkey: &Keys, invoice_info: InvoiceInfo) -> Result<()>;
+
+    /// Update Invoice for given payment hash
+    async fn update_invoice(&self, payment_hash: &str, status: InvoiceStatus) -> Result<String>;
+
+    /// Get the most recent invoice for a given pubkey
+    /// invoice must be unpaid and not expired
+    async fn get_unpaid_invoice(&self, pubkey: &Keys) -> Result<Option<InvoiceInfo>>;
+}
+
+// Current time, with a slight forward jitter in seconds
+pub(crate) fn now_jitter(sec: u64) -> u64 {
+    // random time between now, and 10min in future.
+    let mut rng = rand::thread_rng();
+    let jitter_amount = rng.gen_range(0..sec);
+    let now = unix_time();
+    now.saturating_add(jitter_amount)
+}

src/repo/postgres_migration.rs

@@ -0,0 +1,320 @@
+use crate::repo::postgres::PostgresPool;
+use async_trait::async_trait;
+use sqlx::{Executor, Postgres, Transaction};
+
+#[async_trait]
+pub trait Migration {
+    fn serial_number(&self) -> i64;
+    async fn run(&self, tx: &mut Transaction<Postgres>);
+}
+
+struct SimpleSqlMigration {
+    pub serial_number: i64,
+    pub sql: Vec<&'static str>,
+}
+
+#[async_trait]
+impl Migration for SimpleSqlMigration {
+    fn serial_number(&self) -> i64 {
+        self.serial_number
+    }
+
+    async fn run(&self, tx: &mut Transaction<Postgres>) {
+        for sql in self.sql.iter() {
+            tx.execute(*sql).await.unwrap();
+        }
+    }
+}
+
+/// Execute all migrations on the database.
+pub async fn run_migrations(db: &PostgresPool) -> crate::error::Result<usize> {
+    prepare_migrations_table(db).await;
+    run_migration(m001::migration(), db).await;
+    let m002_result = run_migration(m002::migration(), db).await;
+    if m002_result == MigrationResult::Upgraded {
+        m002::rebuild_tags(db).await?;
+    }
+    run_migration(m003::migration(), db).await;
+    run_migration(m004::migration(), db).await;
+    run_migration(m005::migration(), db).await;
+    Ok(current_version(db).await as usize)
+}
+
+async fn current_version(db: &PostgresPool) -> i64 {
+    sqlx::query_scalar("SELECT max(serial_number) FROM migrations;")
+        .fetch_one(db)
+        .await
+        .unwrap()
+}
+
+async fn prepare_migrations_table(db: &PostgresPool) {
+    sqlx::query("CREATE TABLE IF NOT EXISTS migrations (serial_number bigint)")
+        .execute(db)
+        .await
+        .unwrap();
+}
+
+// Running a migration was either unnecessary, or completed
+#[derive(PartialEq, Eq, Debug, Clone)]
+enum MigrationResult {
+    Upgraded,
+    NotNeeded,
+}
+
+async fn run_migration(migration: impl Migration, db: &PostgresPool) -> MigrationResult {
+    let row: i64 =
+        sqlx::query_scalar("SELECT COUNT(*) AS count FROM migrations WHERE serial_number = $1")
+            .bind(migration.serial_number())
+            .fetch_one(db)
+            .await
+            .unwrap();
+
+    if row > 0 {
+        return MigrationResult::NotNeeded;
+    }
+
+    let mut transaction = db.begin().await.unwrap();
+    migration.run(&mut transaction).await;
+
+    sqlx::query("INSERT INTO migrations VALUES ($1)")
+        .bind(migration.serial_number())
+        .execute(&mut transaction)
+        .await
+        .unwrap();
+
+    transaction.commit().await.unwrap();
+    MigrationResult::Upgraded
+}
+
+mod m001 {
+    use crate::repo::postgres_migration::{Migration, SimpleSqlMigration};
+
+    pub const VERSION: i64 = 1;
+
+    pub fn migration() -> impl Migration {
+        SimpleSqlMigration {
+            serial_number: VERSION,
+            sql: vec![
+                r#"
+-- Events table
+CREATE TABLE "event" (
+	id bytea NOT NULL,
+	pub_key bytea NOT NULL,
+	created_at timestamp with time zone NOT NULL,
+	kind integer NOT NULL,
+	"content" bytea NOT NULL,
+	hidden bit(1) NOT NULL DEFAULT 0::bit(1),
+	delegated_by bytea NULL,
+	first_seen timestamp with time zone NOT NULL DEFAULT now(),
+	CONSTRAINT event_pkey PRIMARY KEY (id)
+);
+CREATE INDEX event_created_at_idx ON "event" (created_at,kind);
+CREATE INDEX event_pub_key_idx ON "event" (pub_key);
+CREATE INDEX event_delegated_by_idx ON "event" (delegated_by);
+
+-- Tags table
+CREATE TABLE "tag" (
+	id int8 NOT NULL GENERATED BY DEFAULT AS IDENTITY,
+	event_id bytea NOT NULL,
+	"name" varchar NOT NULL,
+	value bytea NOT NULL,
+	CONSTRAINT tag_fk FOREIGN KEY (event_id) REFERENCES "event"(id) ON DELETE CASCADE
+);
+CREATE INDEX tag_event_id_idx ON tag USING btree (event_id, name);
+CREATE INDEX tag_value_idx ON tag USING btree (value);
+
+-- NIP-05 Verification table
+CREATE TABLE "user_verification" (
+	id int8 NOT NULL GENERATED BY DEFAULT AS IDENTITY,
+	event_id bytea NOT NULL,
+	"name" varchar NOT NULL,
+	verified_at timestamptz NULL,
+	failed_at timestamptz NULL,
+	fail_count int4 NULL DEFAULT 0,
+	CONSTRAINT user_verification_pk PRIMARY KEY (id),
+	CONSTRAINT user_verification_fk FOREIGN KEY (event_id) REFERENCES "event"(id) ON DELETE CASCADE
+);
+CREATE INDEX user_verification_event_id_idx ON user_verification USING btree (event_id);
+CREATE INDEX user_verification_name_idx ON user_verification USING btree (name);
+        "#,
+            ],
+        }
+    }
+}
+
+mod m002 {
+    use async_std::stream::StreamExt;
+    use indicatif::{ProgressBar, ProgressStyle};
+    use sqlx::Row;
+    use std::time::Instant;
+    use tracing::info;
+
+    use crate::event::{single_char_tagname, Event};
+    use crate::repo::postgres::PostgresPool;
+    use crate::repo::postgres_migration::{Migration, SimpleSqlMigration};
+    use crate::utils::is_lower_hex;
+
+    pub const VERSION: i64 = 2;
+
+    pub fn migration() -> impl Migration {
+        SimpleSqlMigration {
+            serial_number: VERSION,
+            sql: vec![
+                r#"
+-- Add tag value column
+ALTER TABLE tag ADD COLUMN value_hex bytea;
+-- Remove not-null constraint
+ALTER TABLE tag ALTER COLUMN value DROP NOT NULL;
+-- Add value index
+CREATE INDEX tag_value_hex_idx ON tag USING btree (value_hex);
+        "#,
+            ],
+        }
+    }
+
+    pub async fn rebuild_tags(db: &PostgresPool) -> crate::error::Result<()> {
+        // Check how many events we have to process
+        let start = Instant::now();
+        let mut tx = db.begin().await.unwrap();
+        let mut update_tx = db.begin().await.unwrap();
+        // Clear out table
+        sqlx::query("DELETE FROM tag;")
+            .execute(&mut update_tx)
+            .await?;
+        {
+            let event_count: i64 = sqlx::query_scalar("SELECT COUNT(*) from event;")
+                .fetch_one(&mut tx)
+                .await
+                .unwrap();
+            let bar = ProgressBar::new(event_count.try_into().unwrap())
+                .with_message("rebuilding tags table");
+            bar.set_style(
+                ProgressStyle::with_template(
+                    "[{elapsed_precise}] {bar:40.white/blue} {pos:>7}/{len:7} [{percent}%] {msg}",
+                )
+                .unwrap(),
+            );
+            let mut events =
+                sqlx::query("SELECT id, content FROM event ORDER BY id;").fetch(&mut tx);
+            while let Some(row) = events.next().await {
+                bar.inc(1);
+                // get the row id and content
+                let row = row.unwrap();
+                let event_id: Vec<u8> = row.get(0);
+                let event_bytes: Vec<u8> = row.get(1);
+                let event: Event = serde_json::from_str(&String::from_utf8(event_bytes).unwrap())?;
+
+                for t in event.tags.iter().filter(|x| x.len() > 1) {
+                    let tagname = t.first().unwrap();
+                    let tagnamechar_opt = single_char_tagname(tagname);
+                    if tagnamechar_opt.is_none() {
+                        continue;
+                    }
+                    // safe because len was > 1
+                    let tagval = t.get(1).unwrap();
+                    // insert as BLOB if we can restore it losslessly.
+                    // this means it needs to be even length and lowercase.
+                    if (tagval.len() % 2 == 0) && is_lower_hex(tagval) {
+                        let q = "INSERT INTO tag (event_id, \"name\", value, value_hex) VALUES ($1, $2, NULL, $3) ON CONFLICT DO NOTHING;";
+                        sqlx::query(q)
+                            .bind(&event_id)
+                            .bind(tagname)
+                            .bind(hex::decode(tagval).ok())
+                            .execute(&mut update_tx)
+                            .await?;
+                    } else {
+                        let q = "INSERT INTO tag (event_id, \"name\", value, value_hex) VALUES ($1, $2, $3, NULL) ON CONFLICT DO NOTHING;";
+                        sqlx::query(q)
+                            .bind(&event_id)
+                            .bind(tagname)
+                            .bind(tagval.as_bytes())
+                            .execute(&mut update_tx)
+                            .await?;
+                    }
+                }
+            }
+            update_tx.commit().await?;
+            bar.finish();
+        }
+        info!("rebuilt tags in {:?}", start.elapsed());
+        Ok(())
+    }
+}
+
+mod m003 {
+    use crate::repo::postgres_migration::{Migration, SimpleSqlMigration};
+
+    pub const VERSION: i64 = 3;
+
+    pub fn migration() -> impl Migration {
+        SimpleSqlMigration {
+            serial_number: VERSION,
+            sql: vec![
+                r#"
+-- Add unique constraint on tag
+ALTER TABLE tag ADD CONSTRAINT unique_constraint_name UNIQUE (event_id, "name", value, value_hex);
+        "#,
+            ],
+        }
+    }
+}
+
+mod m004 {
+    use crate::repo::postgres_migration::{Migration, SimpleSqlMigration};
+
+    pub const VERSION: i64 = 4;
+
+    pub fn migration() -> impl Migration {
+        SimpleSqlMigration {
+            serial_number: VERSION,
+            sql: vec![
+                r#"
+-- Add expiration time for events
+ALTER TABLE event ADD COLUMN expires_at timestamp(0) with time zone;
+-- Index expiration time
+CREATE INDEX event_expires_at_idx ON "event" (expires_at);
+        "#,
+            ],
+        }
+    }
+}
+
+mod m005 {
+    use crate::repo::postgres_migration::{Migration, SimpleSqlMigration};
+
+    pub const VERSION: i64 = 5;
+
+    pub fn migration() -> impl Migration {
+        SimpleSqlMigration {
+            serial_number: VERSION,
+            sql: vec![
+                r#"
+-- Create account table
+CREATE TABLE "account" (
+    pubkey varchar NOT NULL,
+    is_admitted BOOLEAN NOT NULL DEFAULT FALSE,
+    balance BIGINT NOT NULL DEFAULT 0,
+    tos_accepted_at TIMESTAMP,
+    CONSTRAINT account_pkey PRIMARY KEY (pubkey)
+);
+
+CREATE TYPE status AS ENUM ('Paid', 'Unpaid', 'Expired');
+
+
+CREATE TABLE "invoice" (
+    payment_hash varchar NOT NULL,
+    pubkey varchar NOT NULL,
+    invoice varchar NOT NULL,
+    amount BIGINT NOT NULL,
+    status status NOT NULL DEFAULT 'Unpaid',
+    description varchar,
+    created_at timestamp,
+    confirmed_at timestamp,
+    CONSTRAINT invoice_payment_hash PRIMARY KEY (payment_hash),
+    CONSTRAINT invoice_pubkey_fkey FOREIGN KEY (pubkey) REFERENCES account (pubkey) ON DELETE CASCADE
+);
+        "#,
+            ],
+        }
+    }
+}

src/repo/sqlite_migration.rs

@@ -0,0 +1,841 @@
+//! Database schema and migrations
+use crate::db::PooledConnection;
+use crate::error::Result;
+use crate::event::{single_char_tagname, Event};
+use crate::utils::is_lower_hex;
+use const_format::formatcp;
+use indicatif::{ProgressBar, ProgressStyle};
+use rusqlite::limits::Limit;
+use rusqlite::params;
+use rusqlite::Connection;
+use std::cmp::Ordering;
+use std::time::Instant;
+use tracing::{debug, error, info};
+
+/// Startup DB Pragmas
+pub const STARTUP_SQL: &str = r##"
+PRAGMA main.synchronous = NORMAL;
+PRAGMA foreign_keys = ON;
+PRAGMA journal_size_limit = 32768;
+PRAGMA temp_store = 2; -- use memory, not temp files
+PRAGMA main.cache_size = 20000; -- 80MB max cache size per conn
+pragma mmap_size = 0; -- disable mmap (default)
+"##;
+
+/// Latest database version
+pub const DB_VERSION: usize = 18;
+
+/// Schema definition
+const INIT_SQL: &str = formatcp!(
+    r##"
+-- Database settings
+PRAGMA encoding = "UTF-8";
+PRAGMA journal_mode = WAL;
+PRAGMA auto_vacuum = FULL;
+PRAGMA main.synchronous=NORMAL;
+PRAGMA foreign_keys = ON;
+PRAGMA application_id = 1654008667;
+PRAGMA user_version = {};
+
+-- Event Table
+CREATE TABLE IF NOT EXISTS event (
+id INTEGER PRIMARY KEY,
+event_hash BLOB NOT NULL, -- 32-byte SHA256 hash
+first_seen INTEGER NOT NULL, -- when the event was first seen (not authored!) (seconds since 1970)
+created_at INTEGER NOT NULL, -- when the event was authored
+expires_at INTEGER, -- when the event expires and may be deleted
+author BLOB NOT NULL, -- author pubkey
+delegated_by BLOB, -- delegator pubkey (NIP-26)
+kind INTEGER NOT NULL, -- event kind
+hidden INTEGER, -- relevant for queries
+content TEXT NOT NULL -- serialized json of event object
+);
+
+-- Event Indexes
+CREATE UNIQUE INDEX IF NOT EXISTS event_hash_index ON event(event_hash);
+CREATE INDEX IF NOT EXISTS author_index ON event(author);
+CREATE INDEX IF NOT EXISTS kind_index ON event(kind);
+CREATE INDEX IF NOT EXISTS created_at_index ON event(created_at);
+CREATE INDEX IF NOT EXISTS delegated_by_index ON event(delegated_by);
+CREATE INDEX IF NOT EXISTS event_composite_index ON event(kind,created_at);
+CREATE INDEX IF NOT EXISTS kind_author_index ON event(kind,author);
+CREATE INDEX IF NOT EXISTS kind_created_at_index ON event(kind,created_at);
+CREATE INDEX IF NOT EXISTS author_created_at_index ON event(author,created_at);
+CREATE INDEX IF NOT EXISTS author_kind_index ON event(author,kind);
+CREATE INDEX IF NOT EXISTS event_expiration ON event(expires_at);
+
+-- Tag Table
+-- Tag values are stored as either a BLOB (if they come in as a
+-- hex-string), or TEXT otherwise.
+-- This means that searches need to select the appropriate column.
+-- We duplicate the kind/created_at to make indexes much more efficient.
+CREATE TABLE IF NOT EXISTS tag (
+id INTEGER PRIMARY KEY,
+event_id INTEGER NOT NULL, -- an event ID that contains a tag.
+name TEXT, -- the tag name ("p", "e", whatever)
+value TEXT, -- the tag value, if not hex.
+value_hex BLOB, -- the tag value, if it can be interpreted as a lowercase hex string.
+created_at INTEGER NOT NULL, -- when the event was authored
+kind INTEGER NOT NULL, -- event kind
+FOREIGN KEY(event_id) REFERENCES event(id) ON UPDATE CASCADE ON DELETE CASCADE
+);
+CREATE INDEX IF NOT EXISTS tag_val_index ON tag(value);
+CREATE INDEX IF NOT EXISTS tag_composite_index ON tag(event_id,name,value);
+CREATE INDEX IF NOT EXISTS tag_name_eid_index ON tag(name,event_id,value);
+CREATE INDEX IF NOT EXISTS tag_covering_index ON tag(name,kind,value,created_at,event_id);
+
+-- NIP-05 User Validation
+CREATE TABLE IF NOT EXISTS user_verification (
+id INTEGER PRIMARY KEY,
+metadata_event INTEGER NOT NULL, -- the metadata event used for this validation.
+name TEXT NOT NULL, -- the nip05 field value (user@domain).
+verified_at INTEGER, -- timestamp this author/nip05 was most recently verified.
+failed_at INTEGER, -- timestamp a verification attempt failed (host down).
+failure_count INTEGER DEFAULT 0, -- number of consecutive failures.
+FOREIGN KEY(metadata_event) REFERENCES event(id) ON UPDATE CASCADE ON DELETE CASCADE
+);
+CREATE INDEX IF NOT EXISTS user_verification_name_index ON user_verification(name);
+CREATE INDEX IF NOT EXISTS user_verification_event_index ON user_verification(metadata_event);
+
+-- Create account table
+CREATE TABLE IF NOT EXISTS account (
+pubkey TEXT PRIMARY KEY,
+is_admitted INTEGER NOT NULL DEFAULT 0,
+balance INTEGER NOT NULL DEFAULT 0,
+tos_accepted_at INTEGER
+);
+
+-- Create account index
+CREATE INDEX IF NOT EXISTS user_pubkey_index ON account(pubkey);
+
+-- Invoice table
+CREATE TABLE IF NOT EXISTS invoice (
+payment_hash TEXT PRIMARY KEY,
+pubkey TEXT NOT NULL,
+invoice TEXT NOT NULL,
+amount INTEGER NOT NULL,
+status TEXT CHECK ( status IN ('Paid', 'Unpaid', 'Expired' ) ) NOT NUll DEFAULT 'Unpaid',
+description TEXT,
+created_at INTEGER NOT NULL,
+confirmed_at INTEGER,
+CONSTRAINT invoice_pubkey_fkey FOREIGN KEY (pubkey) REFERENCES account (pubkey) ON DELETE CASCADE
+);
+
+-- Create invoice index
+CREATE INDEX IF NOT EXISTS invoice_pubkey_index ON invoice(pubkey);
+
+
+"##,
+    DB_VERSION
+);
+
+/// Determine the current application database schema version.
+pub fn curr_db_version(conn: &mut Connection) -> Result<usize> {
+    let query = "PRAGMA user_version;";
+    let curr_version = conn.query_row(query, [], |row| row.get(0))?;
+    Ok(curr_version)
+}
+
+/// Determine event count
+pub fn db_event_count(conn: &mut Connection) -> Result<usize> {
+    let query = "SELECT count(*) FROM event;";
+    let count = conn.query_row(query, [], |row| row.get(0))?;
+    Ok(count)
+}
+
+/// Determine tag count
+pub fn db_tag_count(conn: &mut Connection) -> Result<usize> {
+    let query = "SELECT count(*) FROM tag;";
+    let count = conn.query_row(query, [], |row| row.get(0))?;
+    Ok(count)
+}
+
+fn mig_init(conn: &mut PooledConnection) -> usize {
+    match conn.execute_batch(INIT_SQL) {
+        Ok(()) => {
+            info!(
+                "database pragma/schema initialized to v{}, and ready",
+                DB_VERSION
+            );
+        }
+        Err(err) => {
+            error!("update (init) failed: {}", err);
+            panic!("database could not be initialized");
+        }
+    }
+    DB_VERSION
+}
+
+/// Upgrade DB to latest version, and execute pragma settings
+pub fn upgrade_db(conn: &mut PooledConnection) -> Result<usize> {
+    // check the version.
+    let mut curr_version = curr_db_version(conn)?;
+    info!("DB version = {:?}", curr_version);
+
+    debug!(
+        "SQLite max query parameters: {}",
+        conn.limit(Limit::SQLITE_LIMIT_VARIABLE_NUMBER)
+    );
+    debug!(
+        "SQLite max table/blob/text length: {} MB",
+        (f64::from(conn.limit(Limit::SQLITE_LIMIT_LENGTH)) / f64::from(1024 * 1024)).floor()
+    );
+    debug!(
+        "SQLite max SQL length: {} MB",
+        (f64::from(conn.limit(Limit::SQLITE_LIMIT_SQL_LENGTH)) / f64::from(1024 * 1024)).floor()
+    );
+
+    match curr_version.cmp(&DB_VERSION) {
+        // Database is new or not current
+        Ordering::Less => {
+            // initialize from scratch
+            if curr_version == 0 {
+                curr_version = mig_init(conn);
+            }
+            // for initialized but out-of-date schemas, proceed to
+            // upgrade sequentially until we are current.
+            if curr_version == 1 {
+                curr_version = mig_1_to_2(conn)?;
+            }
+            if curr_version == 2 {
+                curr_version = mig_2_to_3(conn)?;
+            }
+            if curr_version == 3 {
+                curr_version = mig_3_to_4(conn)?;
+            }
+            if curr_version == 4 {
+                curr_version = mig_4_to_5(conn)?;
+            }
+            if curr_version == 5 {
+                curr_version = mig_5_to_6(conn)?;
+            }
+            if curr_version == 6 {
+                curr_version = mig_6_to_7(conn)?;
+            }
+            if curr_version == 7 {
+                curr_version = mig_7_to_8(conn)?;
+            }
+            if curr_version == 8 {
+                curr_version = mig_8_to_9(conn)?;
+            }
+            if curr_version == 9 {
+                curr_version = mig_9_to_10(conn)?;
+            }
+            if curr_version == 10 {
+                curr_version = mig_10_to_11(conn)?;
+            }
+            if curr_version == 11 {
+                curr_version = mig_11_to_12(conn)?;
+            }
+            if curr_version == 12 {
+                curr_version = mig_12_to_13(conn)?;
+            }
+            if curr_version == 13 {
+                curr_version = mig_13_to_14(conn)?;
+            }
+            if curr_version == 14 {
+                curr_version = mig_14_to_15(conn)?;
+            }
+            if curr_version == 15 {
+                curr_version = mig_15_to_16(conn)?;
+            }
+            if curr_version == 16 {
+                curr_version = mig_16_to_17(conn)?;
+            }
+            if curr_version == 17 {
+                curr_version = mig_17_to_18(conn)?;
+            }
+
+            if curr_version == DB_VERSION {
+                info!(
+                    "All migration scripts completed successfully.  Welcome to v{}.",
+                    DB_VERSION
+                );
+            }
+        }
+        // Database is current, all is good
+        Ordering::Equal => {
+            debug!("Database version was already current (v{DB_VERSION})");
+        }
+        // Database is newer than what this code understands, abort
+        Ordering::Greater => {
+            panic!(
+                "Database version is newer than supported by this executable (v{curr_version} > v{DB_VERSION})",
+            );
+        }
+    }
+
+    // Setup PRAGMA
+    conn.execute_batch(STARTUP_SQL)?;
+    debug!("SQLite PRAGMA startup completed");
+    Ok(DB_VERSION)
+}
+
+pub fn rebuild_tags(conn: &mut PooledConnection) -> Result<()> {
+    // Check how many events we have to process
+    let count = db_event_count(conn)?;
+    let update_each_percent = 0.05;
+    let mut percent_done = 0.0;
+    let mut events_processed = 0;
+    let start = Instant::now();
+    let tx = conn.transaction()?;
+    {
+        // Clear out table
+        tx.execute("DELETE FROM tag;", [])?;
+        let mut stmt = tx.prepare("select id, content from event order by id;")?;
+        let mut tag_rows = stmt.query([])?;
+        while let Some(row) = tag_rows.next()? {
+            if (events_processed as f32) / (count as f32) > percent_done {
+                info!("Tag update {}% complete...", (100.0 * percent_done).round());
+                percent_done += update_each_percent;
+            }
+            // we want to capture the event_id that had the tag, the tag name, and the tag hex value.
+            let event_id: u64 = row.get(0)?;
+            let event_json: String = row.get(1)?;
+            let event: Event = serde_json::from_str(&event_json)?;
+            // look at each event, and each tag, creating new tag entries if appropriate.
+            for t in event.tags.iter().filter(|x| x.len() > 1) {
+                let tagname = t.first().unwrap();
+                let tagnamechar_opt = single_char_tagname(tagname);
+                if tagnamechar_opt.is_none() {
+                    continue;
+                }
+                // safe because len was > 1
+                let tagval = t.get(1).unwrap();
+                // insert as BLOB if we can restore it losslessly.
+                // this means it needs to be even length and lowercase.
+                if (tagval.len() % 2 == 0) && is_lower_hex(tagval) {
+                    tx.execute(
+                        "INSERT INTO tag (event_id, name, value_hex) VALUES (?1, ?2, ?3);",
+                        params![event_id, tagname, hex::decode(tagval).ok()],
+                    )?;
+                } else {
+                    // otherwise, insert as text
+                    tx.execute(
+                        "INSERT INTO tag (event_id, name, value) VALUES (?1, ?2, ?3);",
+                        params![event_id, tagname, &tagval],
+                    )?;
+                }
+            }
+            events_processed += 1;
+        }
+    }
+    tx.commit()?;
+    info!("rebuilt tags in {:?}", start.elapsed());
+    Ok(())
+}
+
+// Migration Scripts
+
+fn mig_1_to_2(conn: &mut PooledConnection) -> Result<usize> {
+    // only change is adding a hidden column to events.
+    let upgrade_sql = r##"
+ALTER TABLE event ADD hidden INTEGER;
+UPDATE event SET hidden=FALSE;
+PRAGMA user_version = 2;
+"##;
+    match conn.execute_batch(upgrade_sql) {
+        Ok(()) => {
+            info!("database schema upgraded v1 -> v2");
+        }
+        Err(err) => {
+            error!("update (v1->v2) failed: {}", err);
+            panic!("database could not be upgraded");
+        }
+    }
+    Ok(2)
+}
+
+fn mig_2_to_3(conn: &mut PooledConnection) -> Result<usize> {
+    // this version lacks the tag column
+    info!("database schema needs update from 2->3");
+    let upgrade_sql = r##"
+CREATE TABLE IF NOT EXISTS tag (
+id INTEGER PRIMARY KEY,
+event_id INTEGER NOT NULL, -- an event ID that contains a tag.
+name TEXT, -- the tag name ("p", "e", whatever)
+value TEXT, -- the tag value, if not hex.
+value_hex BLOB, -- the tag value, if it can be interpreted as a hex string.
+FOREIGN KEY(event_id) REFERENCES event(id) ON UPDATE CASCADE ON DELETE CASCADE
+);
+PRAGMA user_version = 3;
+"##;
+    // TODO: load existing refs into tag table
+    match conn.execute_batch(upgrade_sql) {
+        Ok(()) => {
+            info!("database schema upgraded v2 -> v3");
+        }
+        Err(err) => {
+            error!("update (v2->v3) failed: {}", err);
+            panic!("database could not be upgraded");
+        }
+    }
+    // iterate over every event/pubkey tag
+    let tx = conn.transaction()?;
+    {
+        let mut stmt = tx.prepare("select event_id, \"e\", lower(hex(referenced_event)) from event_ref union select event_id, \"p\", lower(hex(referenced_pubkey)) from pubkey_ref;")?;
+        let mut tag_rows = stmt.query([])?;
+        while let Some(row) = tag_rows.next()? {
+            // we want to capture the event_id that had the tag, the tag name, and the tag hex value.
+            let event_id: u64 = row.get(0)?;
+            let tag_name: String = row.get(1)?;
+            let tag_value: String = row.get(2)?;
+            // this will leave behind p/e tags that were non-hex, but they are invalid anyways.
+            if is_lower_hex(&tag_value) {
+                tx.execute(
+                    "INSERT INTO tag (event_id, name, value_hex) VALUES (?1, ?2, ?3);",
+                    params![event_id, tag_name, hex::decode(&tag_value).ok()],
+                )?;
+            }
+        }
+    }
+    info!("Updated tag values");
+    tx.commit()?;
+    Ok(3)
+}
+
+fn mig_3_to_4(conn: &mut PooledConnection) -> Result<usize> {
+    info!("database schema needs update from 3->4");
+    let upgrade_sql = r##"
+-- incoming metadata events with nip05
+CREATE TABLE IF NOT EXISTS user_verification (
+id INTEGER PRIMARY KEY,
+metadata_event INTEGER NOT NULL, -- the metadata event used for this validation.
+name TEXT NOT NULL, -- the nip05 field value (user@domain).
+verified_at INTEGER, -- timestamp this author/nip05 was most recently verified.
+failed_at INTEGER, -- timestamp a verification attempt failed (host down).
+failure_count INTEGER DEFAULT 0, -- number of consecutive failures.
+FOREIGN KEY(metadata_event) REFERENCES event(id) ON UPDATE CASCADE ON DELETE CASCADE
+);
+CREATE INDEX IF NOT EXISTS user_verification_name_index ON user_verification(name);
+CREATE INDEX IF NOT EXISTS user_verification_event_index ON user_verification(metadata_event);
+PRAGMA user_version = 4;
+"##;
+    match conn.execute_batch(upgrade_sql) {
+        Ok(()) => {
+            info!("database schema upgraded v3 -> v4");
+        }
+        Err(err) => {
+            error!("update (v3->v4) failed: {}", err);
+            panic!("database could not be upgraded");
+        }
+    }
+    Ok(4)
+}
+
+fn mig_4_to_5(conn: &mut PooledConnection) -> Result<usize> {
+    info!("database schema needs update from 4->5");
+    let upgrade_sql = r##"
+DROP TABLE IF EXISTS event_ref;
+DROP TABLE IF EXISTS pubkey_ref;
+PRAGMA user_version=5;
+"##;
+    match conn.execute_batch(upgrade_sql) {
+        Ok(()) => {
+            info!("database schema upgraded v4 -> v5");
+        }
+        Err(err) => {
+            error!("update (v4->v5) failed: {}", err);
+            panic!("database could not be upgraded");
+        }
+    }
+    Ok(5)
+}
+
+fn mig_5_to_6(conn: &mut PooledConnection) -> Result<usize> {
+    info!("database schema needs update from 5->6");
+    // We need to rebuild the tags table.  iterate through the
+    // event table.  build event from json, insert tags into a
+    // fresh tag table.  This was needed due to a logic error in
+    // how hex-like tags got indexed.
+    let start = Instant::now();
+    let tx = conn.transaction()?;
+    {
+        // Clear out table
+        tx.execute("DELETE FROM tag;", [])?;
+        let mut stmt = tx.prepare("select id, content from event order by id;")?;
+        let mut tag_rows = stmt.query([])?;
+        while let Some(row) = tag_rows.next()? {
+            let event_id: u64 = row.get(0)?;
+            let event_json: String = row.get(1)?;
+            let event: Event = serde_json::from_str(&event_json)?;
+            // look at each event, and each tag, creating new tag entries if appropriate.
+            for t in event.tags.iter().filter(|x| x.len() > 1) {
+                let tagname = t.first().unwrap();
+                let tagnamechar_opt = single_char_tagname(tagname);
+                if tagnamechar_opt.is_none() {
+                    continue;
+                }
+                // safe because len was > 1
+                let tagval = t.get(1).unwrap();
+                // insert as BLOB if we can restore it losslessly.
+                // this means it needs to be even length and lowercase.
+                if (tagval.len() % 2 == 0) && is_lower_hex(tagval) {
+                    tx.execute(
+                        "INSERT INTO tag (event_id, name, value_hex) VALUES (?1, ?2, ?3);",
+                        params![event_id, tagname, hex::decode(tagval).ok()],
+                    )?;
+                } else {
+                    // otherwise, insert as text
+                    tx.execute(
+                        "INSERT INTO tag (event_id, name, value) VALUES (?1, ?2, ?3);",
+                        params![event_id, tagname, &tagval],
+                    )?;
+                }
+            }
+        }
+        tx.execute("PRAGMA user_version = 6;", [])?;
+    }
+    tx.commit()?;
+    info!("database schema upgraded v5 -> v6 in {:?}", start.elapsed());
+    // vacuum after large table modification
+    let start = Instant::now();
+    conn.execute("VACUUM;", [])?;
+    info!("vacuumed DB after tags rebuild in {:?}", start.elapsed());
+    Ok(6)
+}
+
+fn mig_6_to_7(conn: &mut PooledConnection) -> Result<usize> {
+    info!("database schema needs update from 6->7");
+    let upgrade_sql = r##"
+ALTER TABLE event ADD delegated_by BLOB;
+CREATE INDEX IF NOT EXISTS delegated_by_index ON event(delegated_by);
+PRAGMA user_version = 7;
+"##;
+    match conn.execute_batch(upgrade_sql) {
+        Ok(()) => {
+            info!("database schema upgraded v6 -> v7");
+        }
+        Err(err) => {
+            error!("update (v6->v7) failed: {}", err);
+            panic!("database could not be upgraded");
+        }
+    }
+    Ok(7)
+}
+
+fn mig_7_to_8(conn: &mut PooledConnection) -> Result<usize> {
+    info!("database schema needs update from 7->8");
+    // Remove redundant indexes, and add a better multi-column index.
+    let upgrade_sql = r##"
+DROP INDEX IF EXISTS created_at_index;
+DROP INDEX IF EXISTS kind_index;
+CREATE INDEX IF NOT EXISTS event_composite_index ON event(kind,created_at);
+PRAGMA user_version = 8;
+"##;
+    match conn.execute_batch(upgrade_sql) {
+        Ok(()) => {
+            info!("database schema upgraded v7 -> v8");
+        }
+        Err(err) => {
+            error!("update (v7->v8) failed: {}", err);
+            panic!("database could not be upgraded");
+        }
+    }
+    Ok(8)
+}
+
+fn mig_8_to_9(conn: &mut PooledConnection) -> Result<usize> {
+    info!("database schema needs update from 8->9");
+    // Those old indexes were actually helpful...
+    let upgrade_sql = r##"
+CREATE INDEX IF NOT EXISTS created_at_index ON event(created_at);
+CREATE INDEX IF NOT EXISTS event_composite_index ON event(kind,created_at);
+PRAGMA user_version = 9;
+"##;
+    match conn.execute_batch(upgrade_sql) {
+        Ok(()) => {
+            info!("database schema upgraded v8 -> v9");
+        }
+        Err(err) => {
+            error!("update (v8->v9) failed: {}", err);
+            panic!("database could not be upgraded");
+        }
+    }
+    Ok(9)
+}
+
+fn mig_9_to_10(conn: &mut PooledConnection) -> Result<usize> {
+    info!("database schema needs update from 9->10");
+    // Those old indexes were actually helpful...
+    let upgrade_sql = r##"
+CREATE INDEX IF NOT EXISTS tag_composite_index ON tag(event_id,name,value_hex,value);
+PRAGMA user_version = 10;
+"##;
+    match conn.execute_batch(upgrade_sql) {
+        Ok(()) => {
+            info!("database schema upgraded v9 -> v10");
+        }
+        Err(err) => {
+            error!("update (v9->v10) failed: {}", err);
+            panic!("database could not be upgraded");
+        }
+    }
+    Ok(10)
+}
+
+fn mig_10_to_11(conn: &mut PooledConnection) -> Result<usize> {
+    info!("database schema needs update from 10->11");
+    // Those old indexes were actually helpful...
+    let upgrade_sql = r##"
+CREATE INDEX IF NOT EXISTS tag_name_eid_index ON tag(name,event_id,value_hex);
+reindex;
+pragma optimize;
+PRAGMA user_version = 11;
+"##;
+    match conn.execute_batch(upgrade_sql) {
+        Ok(()) => {
+            info!("database schema upgraded v10 -> v11");
+        }
+        Err(err) => {
+            error!("update (v10->v11) failed: {}", err);
+            panic!("database could not be upgraded");
+        }
+    }
+    Ok(11)
+}
+
+fn mig_11_to_12(conn: &mut PooledConnection) -> Result<usize> {
+    info!("database schema needs update from 11->12");
+    let start = Instant::now();
+    let tx = conn.transaction()?;
+    {
+        // Lookup every replaceable event
+        let mut stmt = tx.prepare("select kind,author from event where kind in (0,3,41) or (kind>=10000 and kind<20000) order by id;")?;
+        let mut replaceable_rows = stmt.query([])?;
+        info!("updating replaceable events; this could take awhile...");
+        while let Some(row) = replaceable_rows.next()? {
+            // we want to capture the event_id that had the tag, the tag name, and the tag hex value.
+            let event_kind: u64 = row.get(0)?;
+            let event_author: Vec<u8> = row.get(1)?;
+            tx.execute(
+                "UPDATE event SET hidden=TRUE WHERE hidden!=TRUE and kind=? and author=? and id NOT IN (SELECT id FROM event WHERE kind=? AND author=? ORDER BY created_at DESC LIMIT 1)",
+                params![event_kind, event_author, event_kind, event_author],
+            )?;
+        }
+        tx.execute("PRAGMA user_version = 12;", [])?;
+    }
+    tx.commit()?;
+    info!(
+        "database schema upgraded v11 -> v12 in {:?}",
+        start.elapsed()
+    );
+    // vacuum after large table modification
+    let start = Instant::now();
+    conn.execute("VACUUM;", [])?;
+    info!(
+        "vacuumed DB after hidden event cleanup in {:?}",
+        start.elapsed()
+    );
+    Ok(12)
+}
+
+fn mig_12_to_13(conn: &mut PooledConnection) -> Result<usize> {
+    info!("database schema needs update from 12->13");
+    let upgrade_sql = r##"
+CREATE INDEX IF NOT EXISTS kind_author_index ON event(kind,author);
+reindex;
+pragma optimize;
+PRAGMA user_version = 13;
+"##;
+    match conn.execute_batch(upgrade_sql) {
+        Ok(()) => {
+            info!("database schema upgraded v12 -> v13");
+        }
+        Err(err) => {
+            error!("update (v12->v13) failed: {}", err);
+            panic!("database could not be upgraded");
+        }
+    }
+    Ok(13)
+}
+
+fn mig_13_to_14(conn: &mut PooledConnection) -> Result<usize> {
+    info!("database schema needs update from 13->14");
+    let upgrade_sql = r##"
+CREATE INDEX IF NOT EXISTS kind_index ON event(kind);
+CREATE INDEX IF NOT EXISTS kind_created_at_index ON event(kind,created_at);
+pragma optimize;
+PRAGMA user_version = 14;
+"##;
+    match conn.execute_batch(upgrade_sql) {
+        Ok(()) => {
+            info!("database schema upgraded v13 -> v14");
+        }
+        Err(err) => {
+            error!("update (v13->v14) failed: {}", err);
+            panic!("database could not be upgraded");
+        }
+    }
+    Ok(14)
+}
+
+fn mig_14_to_15(conn: &mut PooledConnection) -> Result<usize> {
+    info!("database schema needs update from 14->15");
+    let upgrade_sql = r##"
+CREATE INDEX IF NOT EXISTS author_created_at_index ON event(author,created_at);
+CREATE INDEX IF NOT EXISTS author_kind_index ON event(author,kind);
+PRAGMA user_version = 15;
+"##;
+    match conn.execute_batch(upgrade_sql) {
+        Ok(()) => {
+            info!("database schema upgraded v14 -> v15");
+        }
+        Err(err) => {
+            error!("update (v14->v15) failed: {}", err);
+            panic!("database could not be upgraded");
+        }
+    }
+    // clear out hidden events
+    let clear_hidden_sql = r##"DELETE FROM event WHERE HIDDEN=true;"##;
+    info!("removing hidden events; this may take awhile...");
+    match conn.execute_batch(clear_hidden_sql) {
+        Ok(()) => {
+            info!("all hidden events removed");
+        }
+        Err(err) => {
+            error!("delete failed: {}", err);
+            panic!("could not remove hidden events");
+        }
+    }
+    Ok(15)
+}
+
+fn mig_15_to_16(conn: &mut PooledConnection) -> Result<usize> {
+    let count = db_event_count(conn)?;
+    info!("database schema needs update from 15->16 (this may take a few minutes)");
+    let upgrade_sql = r##"
+DROP TABLE tag;
+CREATE TABLE tag (
+id INTEGER PRIMARY KEY,
+event_id INTEGER NOT NULL, -- an event ID that contains a tag.
+name TEXT, -- the tag name ("p", "e", whatever)
+value TEXT, -- the tag value, if not hex.
+created_at INTEGER NOT NULL, -- when the event was authored
+kind INTEGER NOT NULL, -- event kind
+FOREIGN KEY(event_id) REFERENCES event(id) ON UPDATE CASCADE ON DELETE CASCADE
+);
+CREATE INDEX IF NOT EXISTS tag_val_index ON tag(value);
+CREATE INDEX IF NOT EXISTS tag_composite_index ON tag(event_id,name,value);
+CREATE INDEX IF NOT EXISTS tag_name_eid_index ON tag(name,event_id,value);
+CREATE INDEX IF NOT EXISTS tag_covering_index ON tag(name,kind,value,created_at,event_id);
+"##;
+
+    let start = Instant::now();
+    let tx = conn.transaction()?;
+
+    let bar = ProgressBar::new(count.try_into().unwrap()).with_message("rebuilding tags table");
+    bar.set_style(
+        ProgressStyle::with_template(
+            "[{elapsed_precise}] {bar:40.white/blue} {pos:>7}/{len:7} [{percent}%] {msg}",
+        )
+        .unwrap(),
+    );
+    {
+        tx.execute_batch(upgrade_sql)?;
+        let mut stmt =
+            tx.prepare("select id, kind, created_at, content from event order by id;")?;
+        let mut tag_rows = stmt.query([])?;
+        let mut count = 0;
+        while let Some(row) = tag_rows.next()? {
+            count += 1;
+            if count % 10 == 0 {
+                bar.inc(10);
+            }
+            let event_id: u64 = row.get(0)?;
+            let kind: u64 = row.get(1)?;
+            let created_at: u64 = row.get(2)?;
+            let event_json: String = row.get(3)?;
+            let event: Event = serde_json::from_str(&event_json)?;
+            // look at each event, and each tag, creating new tag entries if appropriate.
+            for t in event.tags.iter().filter(|x| x.len() > 1) {
+                let tagname = t.first().unwrap();
+                let tagnamechar_opt = single_char_tagname(tagname);
+                if tagnamechar_opt.is_none() {
+                    continue;
+                }
+                // safe because len was > 1
+                let tagval = t.get(1).unwrap();
+                // otherwise, insert as text
+                tx.execute(
+                    "INSERT INTO tag (event_id, name, value, kind, created_at) VALUES (?1, ?2, ?3, ?4, ?5);",
+                    params![event_id, tagname, &tagval, kind, created_at],
+                )?;
+            }
+        }
+        tx.execute("PRAGMA user_version = 16;", [])?;
+    }
+    bar.finish();
+    tx.commit()?;
+    info!(
+        "database schema upgraded v15 -> v16 in {:?}",
+        start.elapsed()
+    );
+    Ok(16)
+}
+
+fn mig_16_to_17(conn: &mut PooledConnection) -> Result<usize> {
+    info!("database schema needs update from 16->17");
+    let upgrade_sql = r##"
+ALTER TABLE event ADD COLUMN expires_at INTEGER;
+CREATE INDEX IF NOT EXISTS event_expiration ON event(expires_at);
+PRAGMA user_version = 17;
+"##;
+    match conn.execute_batch(upgrade_sql) {
+        Ok(()) => {
+            info!("database schema upgraded v16 -> v17");
+        }
+        Err(err) => {
+            error!("update (v16->v17) failed: {}", err);
+            panic!("database could not be upgraded");
+        }
+    }
+    Ok(17)
+}
+
+fn mig_17_to_18(conn: &mut PooledConnection) -> Result<usize> {
+    info!("database schema needs update from 17->18");
+    let upgrade_sql = r##"
+-- Create invoices table
+CREATE TABLE IF NOT EXISTS invoice (
+payment_hash TEXT PRIMARY KEY,
+pubkey TEXT NOT NULL,
+invoice TEXT NOT NULL,
+amount INTEGER NOT NULL,
+status TEXT CHECK ( status IN ('Paid', 'Unpaid', 'Expired' ) ) NOT NUll DEFAULT 'Unpaid',
+description TEXT,
+created_at INTEGER NOT NULL,
+confirmed_at INTEGER,
+CONSTRAINT invoice_pubkey_fkey FOREIGN KEY (pubkey) REFERENCES account (pubkey) ON DELETE CASCADE
+);
+
+-- Create invoice index
+CREATE INDEX IF NOT EXISTS invoice_pubkey_index ON invoice(pubkey);
+
+-- Create account table
+
+CREATE TABLE IF NOT EXISTS account (
+pubkey TEXT PRIMARY KEY,
+is_admitted INTEGER NOT NULL DEFAULT 0,
+balance INTEGER NOT NULL DEFAULT 0,
+tos_accepted_at INTEGER
+);
+
+-- Create account index
+CREATE INDEX IF NOT EXISTS account_pubkey_index ON account(pubkey);
+
+
+pragma optimize;
+PRAGMA user_version = 18;
+"##;
+    match conn.execute_batch(upgrade_sql) {
+        Ok(()) => {
+            info!("database schema upgraded v17 -> v18");
+        }
+        Err(err) => {
+            error!("update (v17->v18) failed: {}", err);
+            panic!("database could not be upgraded");
+        }
+    }
+    Ok(18)
+}

src/schema.rs

@@ -1,290 +0,0 @@
-//! Database schema and migrations
-use crate::db::PooledConnection;
-use crate::error::Result;
-use crate::event::{single_char_tagname, Event};
-use crate::utils::is_lower_hex;
-use log::*;
-use rusqlite::limits::Limit;
-use rusqlite::params;
-use rusqlite::Connection;
-use std::time::Instant;
-
-/// Startup DB Pragmas
-pub const STARTUP_SQL: &str = r##"
-PRAGMA main.synchronous=NORMAL;
-PRAGMA foreign_keys = ON;
-pragma mmap_size = 536870912; -- 512MB of mmap
-"##;
-
-/// Schema definition
-const INIT_SQL: &str = r##"
--- Database settings
-PRAGMA encoding = "UTF-8";
-PRAGMA journal_mode=WAL;
-PRAGMA main.synchronous=NORMAL;
-PRAGMA foreign_keys = ON;
-PRAGMA application_id = 1654008667;
-PRAGMA user_version = 6;
-
--- Event Table
-CREATE TABLE IF NOT EXISTS event (
-id INTEGER PRIMARY KEY,
-event_hash BLOB NOT NULL, -- 4-byte hash
-first_seen INTEGER NOT NULL, -- when the event was first seen (not authored!) (seconds since 1970)
-created_at INTEGER NOT NULL, -- when the event was authored
-author BLOB NOT NULL, -- author pubkey
-kind INTEGER NOT NULL, -- event kind
-hidden INTEGER, -- relevant for queries
-content TEXT NOT NULL -- serialized json of event object
-);
-
--- Event Indexes
-CREATE UNIQUE INDEX IF NOT EXISTS event_hash_index ON event(event_hash);
-CREATE INDEX IF NOT EXISTS created_at_index ON event(created_at);
-CREATE INDEX IF NOT EXISTS author_index ON event(author);
-CREATE INDEX IF NOT EXISTS kind_index ON event(kind);
-
--- Tag Table
--- Tag values are stored as either a BLOB (if they come in as a
--- hex-string), or TEXT otherwise.
--- This means that searches need to select the appropriate column.
-CREATE TABLE IF NOT EXISTS tag (
-id INTEGER PRIMARY KEY,
-event_id INTEGER NOT NULL, -- an event ID that contains a tag.
-name TEXT, -- the tag name ("p", "e", whatever)
-value TEXT, -- the tag value, if not hex.
-value_hex BLOB, -- the tag value, if it can be interpreted as a lowercase hex string.
-FOREIGN KEY(event_id) REFERENCES event(id) ON UPDATE CASCADE ON DELETE CASCADE
-);
-CREATE INDEX IF NOT EXISTS tag_val_index ON tag(value);
-CREATE INDEX IF NOT EXISTS tag_val_hex_index ON tag(value_hex);
-
--- NIP-05 User Validation
-CREATE TABLE IF NOT EXISTS user_verification (
-id INTEGER PRIMARY KEY,
-metadata_event INTEGER NOT NULL, -- the metadata event used for this validation.
-name TEXT NOT NULL, -- the nip05 field value (user@domain).
-verified_at INTEGER, -- timestamp this author/nip05 was most recently verified.
-failed_at INTEGER, -- timestamp a verification attempt failed (host down).
-failure_count INTEGER DEFAULT 0, -- number of consecutive failures.
-FOREIGN KEY(metadata_event) REFERENCES event(id) ON UPDATE CASCADE ON DELETE CASCADE
-);
-CREATE INDEX IF NOT EXISTS user_verification_name_index ON user_verification(name);
-CREATE INDEX IF NOT EXISTS user_verification_event_index ON user_verification(metadata_event);
-"##;
-
-/// Determine the current application database schema version.
-pub fn db_version(conn: &mut Connection) -> Result<usize> {
-    let query = "PRAGMA user_version;";
-    let curr_version = conn.query_row(query, [], |row| row.get(0))?;
-    Ok(curr_version)
-}
-
-/// Upgrade DB to latest version, and execute pragma settings
-pub fn upgrade_db(conn: &mut PooledConnection) -> Result<()> {
-    // check the version.
-    let mut curr_version = db_version(conn)?;
-    info!("DB version = {:?}", curr_version);
-
-    debug!(
-        "SQLite max query parameters: {}",
-        conn.limit(Limit::SQLITE_LIMIT_VARIABLE_NUMBER)
-    );
-    debug!(
-        "SQLite max table/blob/text length: {} MB",
-        (conn.limit(Limit::SQLITE_LIMIT_LENGTH) as f64 / (1024 * 1024) as f64).floor()
-    );
-    debug!(
-        "SQLite max SQL length: {} MB",
-        (conn.limit(Limit::SQLITE_LIMIT_SQL_LENGTH) as f64 / (1024 * 1024) as f64).floor()
-    );
-
-    // initialize from scratch
-    if curr_version == 0 {
-        match conn.execute_batch(INIT_SQL) {
-            Ok(()) => {
-                info!("database pragma/schema initialized to v6, and ready");
-            }
-            Err(err) => {
-                error!("update failed: {}", err);
-                panic!("database could not be initialized");
-            }
-        }
-    }
-    if curr_version == 1 {
-        // only change is adding a hidden column to events.
-        let upgrade_sql = r##"
-ALTER TABLE event ADD hidden INTEGER;
-UPDATE event SET hidden=FALSE;
-PRAGMA user_version = 2;
-"##;
-        match conn.execute_batch(upgrade_sql) {
-            Ok(()) => {
-                info!("database schema upgraded v1 -> v2");
-                curr_version = 2;
-            }
-            Err(err) => {
-                error!("update failed: {}", err);
-                panic!("database could not be upgraded");
-            }
-        }
-    }
-    if curr_version == 2 {
-        // this version lacks the tag column
-        info!("database schema needs update from 2->3");
-        let upgrade_sql = r##"
-CREATE TABLE IF NOT EXISTS tag (
-id INTEGER PRIMARY KEY,
-event_id INTEGER NOT NULL, -- an event ID that contains a tag.
-name TEXT, -- the tag name ("p", "e", whatever)
-value TEXT, -- the tag value, if not hex.
-value_hex BLOB, -- the tag value, if it can be interpreted as a hex string.
-FOREIGN KEY(event_id) REFERENCES event(id) ON UPDATE CASCADE ON DELETE CASCADE
-);
-PRAGMA user_version = 3;
-"##;
-        // TODO: load existing refs into tag table
-        match conn.execute_batch(upgrade_sql) {
-            Ok(()) => {
-                info!("database schema upgraded v2 -> v3");
-                curr_version = 3;
-            }
-            Err(err) => {
-                error!("update failed: {}", err);
-                panic!("database could not be upgraded");
-            }
-        }
-        // iterate over every event/pubkey tag
-        let tx = conn.transaction()?;
-        {
-            let mut stmt = tx.prepare("select event_id, \"e\", lower(hex(referenced_event)) from event_ref union select event_id, \"p\", lower(hex(referenced_pubkey)) from pubkey_ref;")?;
-            let mut tag_rows = stmt.query([])?;
-            while let Some(row) = tag_rows.next()? {
-                // we want to capture the event_id that had the tag, the tag name, and the tag hex value.
-                let event_id: u64 = row.get(0)?;
-                let tag_name: String = row.get(1)?;
-                let tag_value: String = row.get(2)?;
-                // this will leave behind p/e tags that were non-hex, but they are invalid anyways.
-                if is_lower_hex(&tag_value) {
-                    tx.execute(
-                        "INSERT INTO tag (event_id, name, value_hex) VALUES (?1, ?2, ?3);",
-                        params![event_id, tag_name, hex::decode(&tag_value).ok()],
-                    )?;
-                }
-            }
-        }
-        tx.commit()?;
-        info!("Upgrade complete");
-    }
-    if curr_version == 3 {
-        info!("database schema needs update from 3->4");
-        let upgrade_sql = r##"
--- incoming metadata events with nip05
-CREATE TABLE IF NOT EXISTS user_verification (
-id INTEGER PRIMARY KEY,
-metadata_event INTEGER NOT NULL, -- the metadata event used for this validation.
-name TEXT NOT NULL, -- the nip05 field value (user@domain).
-verified_at INTEGER, -- timestamp this author/nip05 was most recently verified.
-failed_at INTEGER, -- timestamp a verification attempt failed (host down).
-failure_count INTEGER DEFAULT 0, -- number of consecutive failures.
-FOREIGN KEY(metadata_event) REFERENCES event(id) ON UPDATE CASCADE ON DELETE CASCADE
-);
-CREATE INDEX IF NOT EXISTS user_verification_name_index ON user_verification(name);
-CREATE INDEX IF NOT EXISTS user_verification_event_index ON user_verification(metadata_event);
-PRAGMA user_version = 4;
-"##;
-        match conn.execute_batch(upgrade_sql) {
-            Ok(()) => {
-                info!("database schema upgraded v3 -> v4");
-                curr_version = 4;
-            }
-            Err(err) => {
-                error!("update failed: {}", err);
-                panic!("database could not be upgraded");
-            }
-        }
-    }
-
-    if curr_version == 4 {
-        info!("database schema needs update from 4->5");
-        let upgrade_sql = r##"
-DROP TABLE IF EXISTS event_ref;
-DROP TABLE IF EXISTS pubkey_ref;
-PRAGMA user_version=5;
-"##;
-        match conn.execute_batch(upgrade_sql) {
-            Ok(()) => {
-                info!("database schema upgraded v4 -> v5");
-                // uncomment if we have a newer version
-                //curr_version = 5;
-            }
-            Err(err) => {
-                error!("update failed: {}", err);
-                panic!("database could not be upgraded");
-            }
-        }
-    } else if curr_version == 5 {
-        info!("database schema needs update from 5->6");
-        // We need to rebuild the tags table.  iterate through the
-        // event table.  build event from json, insert tags into a
-        // fresh tag table.  This was needed due to a logic error in
-        // how hex-like tags got indexed.
-        let start = Instant::now();
-        let tx = conn.transaction()?;
-        {
-            // Clear out table
-            tx.execute("DELETE FROM tag;", [])?;
-            let mut stmt = tx.prepare("select id, content from event order by id;")?;
-            let mut tag_rows = stmt.query([])?;
-            while let Some(row) = tag_rows.next()? {
-                // we want to capture the event_id that had the tag, the tag name, and the tag hex value.
-                let event_id: u64 = row.get(0)?;
-                let event_json: String = row.get(1)?;
-                let event: Event = serde_json::from_str(&event_json)?;
-                // look at each event, and each tag, creating new tag entries if appropriate.
-                for t in event.tags.iter().filter(|x| x.len() > 1) {
-                    let tagname = t.get(0).unwrap();
-                    let tagnamechar_opt = single_char_tagname(tagname);
-                    if tagnamechar_opt.is_none() {
-                        continue;
-                    }
-                    // safe because len was > 1
-                    let tagval = t.get(1).unwrap();
-                    // insert as BLOB if we can restore it losslessly.
-                    // this means it needs to be even length and lowercase.
-                    if (tagval.len() % 2 == 0) && is_lower_hex(&tagval) {
-                        tx.execute(
-                            "INSERT INTO tag (event_id, name, value_hex) VALUES (?1, ?2, ?3);",
-                            params![event_id, tagname, hex::decode(&tagval).ok()],
-                        )?;
-                    } else {
-                        // otherwise, insert as text
-                        tx.execute(
-                            "INSERT INTO tag (event_id, name, value) VALUES (?1, ?2, ?3);",
-                            params![event_id, tagname, &tagval],
-                        )?;
-                    }
-                }
-            }
-            tx.execute("PRAGMA user_version = 6;", [])?;
-        }
-        tx.commit()?;
-        info!("database schema upgraded v5 -> v6 in {:?}", start.elapsed());
-        // vacuum after large table modification
-        let start = Instant::now();
-        conn.execute("VACUUM;", [])?;
-        info!("vacuumed DB after tags rebuild in {:?}", start.elapsed());
-    } else if curr_version == 6 {
-        debug!("Database version was already current (v6)");
-    } else if curr_version > 7 {
-        panic!(
-            "Database version is newer than supported by this executable (v{})",
-            curr_version
-        );
-    }
-
-    // Setup PRAGMA
-    conn.execute_batch(STARTUP_SQL)?;
-    debug!("SQLite PRAGMA startup completed");
-    Ok(())
-}

src/subscription.rs

@@ -2,13 +2,14 @@
 use crate::error::Result;
 use crate::event::Event;
 use serde::de::Unexpected;
-use serde::{Deserialize, Deserializer, Serialize};
+use serde::ser::SerializeMap;
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use serde_json::Value;
 use std::collections::HashMap;
 use std::collections::HashSet;
 
 /// Subscription identifier and set of request filters
-#[derive(Serialize, PartialEq, Debug, Clone)]
+#[derive(Serialize, PartialEq, Eq, Debug, Clone)]
 pub struct Subscription {
     pub id: String,
     pub filters: Vec<ReqFilter>,
@@ -19,7 +20,7 @@ pub struct Subscription {
 /// Corresponds to client-provided subscription request elements.  Any
 /// element can be present if it should be used in filtering, or
 /// absent ([`None`]) if it should be ignored.
-#[derive(Serialize, PartialEq, Debug, Clone)]
+#[derive(PartialEq, Eq, Debug, Clone)]
 pub struct ReqFilter {
     /// Event hashes
     pub ids: Option<Vec<String>>,
@@ -34,12 +35,49 @@ pub struct ReqFilter {
     /// Limit number of results
     pub limit: Option<u64>,
     /// Set of tags
-    #[serde(skip)]
     pub tags: Option<HashMap<char, HashSet<String>>>,
     /// Force no matches due to malformed data
+    // we can't represent it in the req filter, so we don't want to
+    // erroneously match.  This basically indicates the req tried to
+    // do something invalid.
     pub force_no_match: bool,
 }
 
+impl Serialize for ReqFilter {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut map = serializer.serialize_map(None)?;
+        if let Some(ids) = &self.ids {
+            map.serialize_entry("ids", &ids)?;
+        }
+        if let Some(kinds) = &self.kinds {
+            map.serialize_entry("kinds", &kinds)?;
+        }
+        if let Some(until) = &self.until {
+            map.serialize_entry("until", until)?;
+        }
+        if let Some(since) = &self.since {
+            map.serialize_entry("since", since)?;
+        }
+        if let Some(limit) = &self.limit {
+            map.serialize_entry("limit", limit)?;
+        }
+        if let Some(authors) = &self.authors {
+            map.serialize_entry("authors", &authors)?;
+        }
+        // serialize tags
+        if let Some(tags) = &self.tags {
+            for (k, v) in tags {
+                let vals: Vec<&String> = v.iter().collect();
+                map.serialize_entry(&format!("#{k}"), &vals)?;
+            }
+        }
+        map.end()
+    }
+}
+
 impl<'de> Deserialize<'de> for ReqFilter {
     fn deserialize<D>(deserializer: D) -> Result<ReqFilter, D::Error>
     where
@@ -62,12 +100,22 @@ impl<'de> Deserialize<'de> for ReqFilter {
             tags: None,
             force_no_match: false,
         };
+        let empty_string = "".into();
         let mut ts = None;
         // iterate through each key, and assign values that exist
-        for (key, val) in filter.into_iter() {
+        for (key, val) in filter {
             // ids
             if key == "ids" {
-                rf.ids = Deserialize::deserialize(val).ok();
+                let raw_ids: Option<Vec<String>> = Deserialize::deserialize(val).ok();
+                if let Some(a) = raw_ids.as_ref() {
+                    if a.contains(&empty_string) {
+                        return Err(serde::de::Error::invalid_type(
+                            Unexpected::Other("prefix matches must not be empty strings"),
+                            &"a json object",
+                        ));
+                    }
+                }
+                rf.ids = raw_ids;
             } else if key == "kinds" {
                 rf.kinds = Deserialize::deserialize(val).ok();
             } else if key == "since" {
@@ -77,7 +125,16 @@ impl<'de> Deserialize<'de> for ReqFilter {
             } else if key == "limit" {
                 rf.limit = Deserialize::deserialize(val).ok();
             } else if key == "authors" {
-                rf.authors = Deserialize::deserialize(val).ok();
+                let raw_authors: Option<Vec<String>> = Deserialize::deserialize(val).ok();
+                if let Some(a) = raw_authors.as_ref() {
+                    if a.contains(&empty_string) {
+                        return Err(serde::de::Error::invalid_type(
+                            Unexpected::Other("prefix matches must not be empty strings"),
+                            &"a json object",
+                        ));
+                    }
+                }
+                rf.authors = raw_authors;
             } else if key.starts_with('#') && key.len() > 1 && val.is_array() {
                 if let Some(tag_search) = tag_search_char_from_filter(key) {
                     if ts.is_none() {
@@ -87,7 +144,7 @@ impl<'de> Deserialize<'de> for ReqFilter {
                     if let Some(m) = ts.as_mut() {
                         let tag_vals: Option<Vec<String>> = Deserialize::deserialize(val).ok();
                         if let Some(v) = tag_vals {
-                            let hs = HashSet::from_iter(v.into_iter());
+                            let hs = v.into_iter().collect::<HashSet<_>>();
                             m.insert(tag_search.to_owned(), hs);
                         }
                     };
@@ -110,7 +167,7 @@ fn tag_search_char_from_filter(tagname: &str) -> Option<char> {
     // of a single char.
     let mut tagnamechars = tagname_nohash.chars();
     let firstchar = tagnamechars.next();
-    return match firstchar {
+    match firstchar {
         Some(_) => {
             // check second char
             if tagnamechars.next().is_none() {
@@ -120,7 +177,7 @@ fn tag_search_char_from_filter(tagname: &str) -> Option<char> {
             }
         }
         None => None,
-    };
+    }
 }
 
 impl<'de> Deserialize<'de> for Subscription {
@@ -131,7 +188,7 @@ impl<'de> Deserialize<'de> for Subscription {
         D: Deserializer<'de>,
     {
         let mut v: Value = Deserialize::deserialize(deserializer)?;
-        // this shoud be a 3-or-more element array.
+        // this should be a 3-or-more element array.
         // verify the first element is a String, REQ
         // get the subscription from the second element.
         // convert each of the remaining objects into filters
@@ -168,6 +225,7 @@ impl<'de> Deserialize<'de> for Subscription {
             // create indexes
             filters.push(f);
         }
+        filters.dedup();
         Ok(Subscription {
             id: sub_id.to_owned(),
             filters,
@@ -177,19 +235,52 @@ impl<'de> Deserialize<'de> for Subscription {
 
 impl Subscription {
     /// Get a copy of the subscription identifier.
+    #[must_use]
     pub fn get_id(&self) -> String {
         self.id.clone()
     }
+
+    /// Determine if any filter is requesting historical (database)
+    /// queries.  If every filter has limit:0, we do not need to query the DB.
+    #[must_use]
+    pub fn needs_historical_events(&self) -> bool {
+        self.filters.iter().any(|f| f.limit != Some(0))
+    }
+
     /// Determine if this subscription matches a given [`Event`].  Any
     /// individual filter match is sufficient.
+    #[must_use]
     pub fn interested_in_event(&self, event: &Event) -> bool {
-        for f in self.filters.iter() {
+        for f in &self.filters {
             if f.interested_in_event(event) {
                 return true;
             }
         }
         false
     }
+
+    /// Is this subscription defined as a scraper query
+    pub fn is_scraper(&self) -> bool {
+        for f in &self.filters {
+            let mut precision = 0;
+            if f.ids.is_some() {
+                precision += 2;
+            }
+            if f.authors.is_some() {
+                precision += 1;
+            }
+            if f.kinds.is_some() {
+                precision += 1;
+            }
+            if f.tags.is_some() {
+                precision += 1;
+            }
+            if precision < 2 {
+                return true;
+            }
+        }
+        false
+    }
 }
 
 fn prefix_match(prefixes: &[String], target: &str) -> bool {
@@ -206,15 +297,23 @@ impl ReqFilter {
     fn ids_match(&self, event: &Event) -> bool {
         self.ids
             .as_ref()
-            .map(|vs| prefix_match(vs, &event.id))
-            .unwrap_or(true)
+            .map_or(true, |vs| prefix_match(vs, &event.id))
     }
 
     fn authors_match(&self, event: &Event) -> bool {
         self.authors
             .as_ref()
-            .map(|vs| prefix_match(vs, &event.pubkey))
-            .unwrap_or(true)
+            .map_or(true, |vs| prefix_match(vs, &event.pubkey))
+    }
+
+    fn delegated_authors_match(&self, event: &Event) -> bool {
+        if let Some(delegated_pubkey) = &event.delegated_by {
+            self.authors
+                .as_ref()
+                .map_or(true, |vs| prefix_match(vs, delegated_pubkey))
+        } else {
+            false
+        }
     }
 
     fn tag_match(&self, event: &Event) -> bool {
@@ -235,20 +334,18 @@ impl ReqFilter {
 
     /// Check if this filter either matches, or does not care about the kind.
     fn kind_match(&self, kind: u64) -> bool {
-        self.kinds
-            .as_ref()
-            .map(|ks| ks.contains(&kind))
-            .unwrap_or(true)
+        self.kinds.as_ref().map_or(true, |ks| ks.contains(&kind))
     }
 
     /// Determine if all populated fields in this filter match the provided event.
+    #[must_use]
     pub fn interested_in_event(&self, event: &Event) -> bool {
         //        self.id.as_ref().map(|v| v == &event.id).unwrap_or(true)
         self.ids_match(event)
-            && self.since.map(|t| event.created_at > t).unwrap_or(true)
-            && self.until.map(|t| event.created_at < t).unwrap_or(true)
+            && self.since.map_or(true, |t| event.created_at >= t)
+            && self.until.map_or(true, |t| event.created_at <= t)
             && self.kind_match(event.kind)
-            && self.authors_match(event)
+            && (self.authors_match(event) || self.delegated_authors_match(event))
             && self.tag_match(event)
             && !self.force_no_match
     }
@@ -264,7 +361,7 @@ mod tests {
         let s: Subscription = serde_json::from_str(raw_json)?;
         assert_eq!(s.id, "some-id");
         assert_eq!(s.filters.len(), 1);
-        assert_eq!(s.filters.get(0).unwrap().authors, None);
+        assert_eq!(s.filters.first().unwrap().authors, None);
         Ok(())
     }
 
@@ -280,6 +377,24 @@ mod tests {
         assert!(serde_json::from_str::<Subscription>(raw_json).is_err());
     }
 
+    #[test]
+    fn req_empty_authors_prefix() {
+        let raw_json = "[\"REQ\",\"some-id\",{\"authors\": [\"\"]}]";
+        assert!(serde_json::from_str::<Subscription>(raw_json).is_err());
+    }
+
+    #[test]
+    fn req_empty_ids_prefix() {
+        let raw_json = "[\"REQ\",\"some-id\",{\"ids\": [\"\"]}]";
+        assert!(serde_json::from_str::<Subscription>(raw_json).is_err());
+    }
+
+    #[test]
+    fn req_empty_ids_prefix_mixed() {
+        let raw_json = "[\"REQ\",\"some-id\",{\"ids\": [\"\",\"aaa\"]}]";
+        assert!(serde_json::from_str::<Subscription>(raw_json).is_err());
+    }
+
     #[test]
     fn legacy_filter() {
         // legacy field in filter
@@ -287,13 +402,30 @@ mod tests {
         assert!(serde_json::from_str::<Subscription>(raw_json).is_ok());
     }
 
+    #[test]
+    fn dupe_filter() -> Result<()> {
+        let raw_json = r#"["REQ","some-id",{"kinds": [1984]}, {"kinds": [1984]}]"#;
+        let s: Subscription = serde_json::from_str(raw_json)?;
+        assert_eq!(s.filters.len(), 1);
+        Ok(())
+    }
+
+    #[test]
+    fn dupe_filter_many() -> Result<()> {
+        // duplicate filters in different order
+        let raw_json = r#"["REQ","some-id",{"kinds":[1984]},{"kinds":[1984]},{"kinds":[1984]},{"kinds":[1984]}]"#;
+        let s: Subscription = serde_json::from_str(raw_json)?;
+        assert_eq!(s.filters.len(), 1);
+        Ok(())
+    }
+
     #[test]
     fn author_filter() -> Result<()> {
         let raw_json = r#"["REQ","some-id",{"authors": ["test-author-id"]}]"#;
         let s: Subscription = serde_json::from_str(raw_json)?;
         assert_eq!(s.id, "some-id");
         assert_eq!(s.filters.len(), 1);
-        let first_filter = s.filters.get(0).unwrap();
+        let first_filter = s.filters.first().unwrap();
         assert_eq!(
             first_filter.authors,
             Some(vec!("test-author-id".to_owned()))
@@ -308,6 +440,7 @@ mod tests {
         let e = Event {
             id: "foo".to_owned(),
             pubkey: "abcd".to_owned(),
+            delegated_by: None,
             created_at: 0,
             kind: 0,
             tags: Vec::new(),
@@ -326,6 +459,7 @@ mod tests {
         let e = Event {
             id: "abcd".to_owned(),
             pubkey: "".to_owned(),
+            delegated_by: None,
             created_at: 0,
             kind: 0,
             tags: Vec::new(),
@@ -344,6 +478,7 @@ mod tests {
         let e = Event {
             id: "abcde".to_owned(),
             pubkey: "".to_owned(),
+            delegated_by: None,
             created_at: 0,
             kind: 0,
             tags: Vec::new(),
@@ -363,6 +498,7 @@ mod tests {
         let e = Event {
             id: "abc".to_owned(),
             pubkey: "".to_owned(),
+            delegated_by: None,
             created_at: 50,
             kind: 0,
             tags: Vec::new(),
@@ -386,6 +522,7 @@ mod tests {
         let e = Event {
             id: "abc".to_owned(),
             pubkey: "".to_owned(),
+            delegated_by: None,
             created_at: 150,
             kind: 0,
             tags: Vec::new(),
@@ -407,6 +544,7 @@ mod tests {
         let e = Event {
             id: "abc".to_owned(),
             pubkey: "".to_owned(),
+            delegated_by: None,
             created_at: 50,
             kind: 0,
             tags: Vec::new(),
@@ -425,6 +563,7 @@ mod tests {
         let e = Event {
             id: "abc".to_owned(),
             pubkey: "".to_owned(),
+            delegated_by: None,
             created_at: 1001,
             kind: 0,
             tags: Vec::new(),
@@ -443,6 +582,7 @@ mod tests {
         let e = Event {
             id: "abc".to_owned(),
             pubkey: "".to_owned(),
+            delegated_by: None,
             created_at: 0,
             kind: 0,
             tags: Vec::new(),
@@ -461,6 +601,7 @@ mod tests {
         let e = Event {
             id: "123".to_owned(),
             pubkey: "abc".to_owned(),
+            delegated_by: None,
             created_at: 0,
             kind: 0,
             tags: Vec::new(),
@@ -471,14 +612,15 @@ mod tests {
         assert!(s.interested_in_event(&e));
         Ok(())
     }
-    #[test]
 
+    #[test]
     fn authors_multi_pubkey() -> Result<()> {
         // check for any of a set of authors, against the pubkey
         let s: Subscription = serde_json::from_str(r#"["REQ","xyz",{"authors":["abc", "bcd"]}]"#)?;
         let e = Event {
             id: "123".to_owned(),
             pubkey: "bcd".to_owned(),
+            delegated_by: None,
             created_at: 0,
             kind: 0,
             tags: Vec::new(),
@@ -497,6 +639,7 @@ mod tests {
         let e = Event {
             id: "123".to_owned(),
             pubkey: "xyz".to_owned(),
+            delegated_by: None,
             created_at: 0,
             kind: 0,
             tags: Vec::new(),
@@ -507,4 +650,49 @@ mod tests {
         assert!(!s.interested_in_event(&e));
         Ok(())
     }
+
+    #[test]
+    fn serialize_filter() -> Result<()> {
+        let s: Subscription = serde_json::from_str(
+            r##"["REQ","xyz",{"authors":["abc", "bcd"], "since": 10, "until": 20, "limit":100, "#e": ["foo", "bar"], "#d": ["test"]}]"##,
+        )?;
+        let f = s.filters.first();
+        let serialized = serde_json::to_string(&f)?;
+        let serialized_wrapped = format!(r##"["REQ", "xyz",{}]"##, serialized);
+        let parsed: Subscription = serde_json::from_str(&serialized_wrapped)?;
+        let parsed_filter = parsed.filters.first();
+        if let Some(pf) = parsed_filter {
+            assert_eq!(pf.since, Some(10));
+            assert_eq!(pf.until, Some(20));
+            assert_eq!(pf.limit, Some(100));
+        } else {
+            assert!(false, "filter could not be parsed");
+        }
+        Ok(())
+    }
+
+    #[test]
+    fn is_scraper() -> Result<()> {
+        assert!(serde_json::from_str::<Subscription>(
+            r#"["REQ","some-id",{"kinds": [1984],"since": 123,"limit":1}]"#
+        )?
+        .is_scraper());
+        assert!(serde_json::from_str::<Subscription>(
+            r#"["REQ","some-id",{"kinds": [1984]},{"kinds": [1984],"authors":["aaaa"]}]"#
+        )?
+        .is_scraper());
+        assert!(!serde_json::from_str::<Subscription>(
+            r#"["REQ","some-id",{"kinds": [1984],"authors":["aaaa"]}]"#
+        )?
+        .is_scraper());
+        assert!(
+            !serde_json::from_str::<Subscription>(r#"["REQ","some-id",{"ids": ["aaaa"]}]"#)?
+                .is_scraper()
+        );
+        assert!(!serde_json::from_str::<Subscription>(
+            r##"["REQ","some-id",{"#p": ["aaaa"],"kinds":[1,4]}]"##
+        )?
+        .is_scraper());
+        Ok(())
+    }
 }

src/utils.rs

@@ -1,7 +1,10 @@
 //! Common utility functions
+use bech32::FromBase32;
 use std::time::SystemTime;
+use url::Url;
 
 /// Seconds since 1970.
+#[must_use]
 pub fn unix_time() -> u64 {
     SystemTime::now()
         .duration_since(SystemTime::UNIX_EPOCH)
@@ -10,17 +13,36 @@ pub fn unix_time() -> u64 {
 }
 
 /// Check if a string contains only hex characters.
+#[must_use]
 pub fn is_hex(s: &str) -> bool {
     s.chars().all(|x| char::is_ascii_hexdigit(&x))
 }
 
+/// Check if string is a nip19 string
+pub fn is_nip19(s: &str) -> bool {
+    s.starts_with("npub") || s.starts_with("note")
+}
+
+pub fn nip19_to_hex(s: &str) -> Result<String, bech32::Error> {
+    let (_hrp, data, _checksum) = bech32::decode(s)?;
+    let data = Vec::<u8>::from_base32(&data)?;
+    Ok(hex::encode(data))
+}
+
 /// Check if a string contains only lower-case hex chars.
+#[must_use]
 pub fn is_lower_hex(s: &str) -> bool {
     s.chars().all(|x| {
         (char::is_ascii_lowercase(&x) || char::is_ascii_digit(&x)) && char::is_ascii_hexdigit(&x)
     })
 }
 
+pub fn host_str(url: &str) -> Option<String> {
+    Url::parse(url)
+        .ok()
+        .and_then(|u| u.host_str().map(|s| s.to_string()))
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -28,6 +50,23 @@ mod tests {
     #[test]
     fn lower_hex() {
         let hexstr = "abcd0123";
-        assert_eq!(is_lower_hex(hexstr), true);
+        assert!(is_lower_hex(hexstr));
+    }
+
+    #[test]
+    fn nip19() {
+        let hexkey = "3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d";
+        let nip19key = "npub180cvv07tjdrrgpa0j7j7tmnyl2yr6yr7l8j4s3evf6u64th6gkwsyjh6w6";
+        assert!(!is_nip19(hexkey));
+        assert!(is_nip19(nip19key));
+    }
+
+    #[test]
+    fn nip19_hex() {
+        let nip19key = "npub180cvv07tjdrrgpa0j7j7tmnyl2yr6yr7l8j4s3evf6u64th6gkwsyjh6w6";
+        let expected = "3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d";
+        let got = nip19_to_hex(nip19key).unwrap();
+
+        assert_eq!(expected, got);
     }
 }

tests/cli.rs

@@ -0,0 +1,10 @@
+#[cfg(test)]
+mod tests {
+    use nostr_rs_relay::cli::CLIArgs;
+
+    #[test]
+    fn cli_tests() {
+        use clap::CommandFactory;
+        CLIArgs::command().debug_assert();
+    }
+}

tests/common/mod.rs

@@ -0,0 +1,107 @@
+use anyhow::{anyhow, Result};
+use nostr_rs_relay::config;
+use nostr_rs_relay::server::start_server;
+//use http::{Request, Response};
+use hyper::{Client, StatusCode, Uri};
+use std::net::TcpListener;
+use std::sync::atomic::{AtomicU16, Ordering};
+use std::sync::mpsc as syncmpsc;
+use std::sync::mpsc::{Receiver as MpscReceiver, Sender as MpscSender};
+use std::thread;
+use std::thread::JoinHandle;
+use std::time::Duration;
+use tracing::{debug, info};
+
+pub struct Relay {
+    pub port: u16,
+    pub handle: JoinHandle<()>,
+    pub shutdown_tx: MpscSender<()>,
+}
+
+pub fn start_relay() -> Result<Relay> {
+    // setup tracing
+    let _trace_sub = tracing_subscriber::fmt::try_init();
+    info!("Starting a new relay");
+    // replace default settings
+    let mut settings = config::Settings::default();
+    // identify open port
+    info!("Checking for address...");
+    let port = get_available_port().unwrap();
+    info!("Found open port: {}", port);
+    // bind to local interface only
+    settings.network.address = "127.0.0.1".to_owned();
+    settings.network.port = port;
+    // create an in-memory DB with multiple readers
+    settings.database.in_memory = true;
+    settings.database.min_conn = 4;
+    settings.database.max_conn = 8;
+    let (shutdown_tx, shutdown_rx): (MpscSender<()>, MpscReceiver<()>) = syncmpsc::channel();
+    let handle = thread::spawn(move || {
+        // server will block the thread it is run on.
+        let _ = start_server(&settings, shutdown_rx);
+    });
+    // how do we know the relay has finished starting up?
+    Ok(Relay {
+        port,
+        handle,
+        shutdown_tx,
+    })
+}
+
+// check if the server is healthy via HTTP request
+async fn server_ready(relay: &Relay) -> Result<bool> {
+    let uri: String = format!("http://127.0.0.1:{}/", relay.port);
+    let client = Client::new();
+    let uri: Uri = uri.parse().unwrap();
+    let res = client.get(uri).await?;
+    Ok(res.status() == StatusCode::OK)
+}
+
+pub async fn wait_for_healthy_relay(relay: &Relay) -> Result<()> {
+    // TODO: maximum time to wait for server to become healthy.
+    // give it a little time to start up before we start polling
+    tokio::time::sleep(Duration::from_millis(10)).await;
+    loop {
+        let server_check = server_ready(relay).await;
+        match server_check {
+            Ok(true) => {
+                // server responded with 200-OK.
+                break;
+            }
+            Ok(false) => {
+                // server responded with an error, we're done.
+                return Err(anyhow!("Got non-200-OK from relay"));
+            }
+            Err(_) => {
+                // server is not yet ready, probably connection refused...
+                debug!("Relay not ready, will try again...");
+                tokio::time::sleep(Duration::from_millis(10)).await;
+            }
+        }
+    }
+    info!("relay is ready");
+    Ok(())
+    // simple message sent to web browsers
+    //let mut request = Request::builder()
+    //    .uri("https://www.rust-lang.org/")
+    //    .header("User-Agent", "my-awesome-agent/1.0");
+}
+
+// from https://elliotekj.com/posts/2017/07/25/find-available-tcp-port-rust/
+// This needed some modification; if multiple tasks all ask for open ports, they will tend to get the same one.
+// instead we should try to try these incrementally/globally.
+
+static PORT_COUNTER: AtomicU16 = AtomicU16::new(4030);
+
+fn get_available_port() -> Option<u16> {
+    let startsearch = PORT_COUNTER.fetch_add(10, Ordering::SeqCst);
+    if startsearch >= 20000 {
+        // wrap around
+        PORT_COUNTER.store(4030, Ordering::Relaxed);
+    }
+    (startsearch..20000).find(|port| port_is_available(*port))
+}
+pub fn port_is_available(port: u16) -> bool {
+    info!("checking on port {}", port);
+    TcpListener::bind(("127.0.0.1", port)).is_ok()
+}

tests/conn.rs

@@ -0,0 +1,356 @@
+#[cfg(test)]
+mod tests {
+    use bitcoin_hashes::hex::ToHex;
+    use bitcoin_hashes::sha256;
+    use bitcoin_hashes::Hash;
+    use secp256k1::rand;
+    use secp256k1::{KeyPair, Secp256k1, XOnlyPublicKey};
+
+    use nostr_rs_relay::conn::ClientConn;
+    use nostr_rs_relay::error::Error;
+    use nostr_rs_relay::event::Event;
+    use nostr_rs_relay::utils::unix_time;
+
+    const RELAY: &str = "wss://nostr.example.com/";
+
+    #[test]
+    fn test_generate_auth_challenge() {
+        let mut client_conn = ClientConn::new("127.0.0.1".into());
+
+        assert_eq!(client_conn.auth_challenge(), None);
+        assert_eq!(client_conn.auth_pubkey(), None);
+
+        client_conn.generate_auth_challenge();
+
+        assert_ne!(client_conn.auth_challenge(), None);
+        assert_eq!(client_conn.auth_pubkey(), None);
+
+        let last_auth_challenge = client_conn.auth_challenge().cloned();
+
+        client_conn.generate_auth_challenge();
+
+        assert_ne!(client_conn.auth_challenge(), None);
+        assert_ne!(
+            client_conn.auth_challenge().unwrap(),
+            &last_auth_challenge.unwrap()
+        );
+        assert_eq!(client_conn.auth_pubkey(), None);
+    }
+
+    #[test]
+    fn test_authenticate_with_valid_event() {
+        let mut client_conn = ClientConn::new("127.0.0.1".into());
+
+        assert_eq!(client_conn.auth_challenge(), None);
+        assert_eq!(client_conn.auth_pubkey(), None);
+
+        client_conn.generate_auth_challenge();
+
+        assert_ne!(client_conn.auth_challenge(), None);
+        assert_eq!(client_conn.auth_pubkey(), None);
+
+        let challenge = client_conn.auth_challenge().unwrap();
+        let event = auth_event(challenge);
+
+        let result = client_conn.authenticate(&event, RELAY);
+
+        assert!(matches!(result, Ok(())));
+        assert_eq!(client_conn.auth_challenge(), None);
+        assert_eq!(client_conn.auth_pubkey(), Some(&event.pubkey));
+    }
+
+    #[test]
+    fn test_fail_to_authenticate_in_invalid_state() {
+        let mut client_conn = ClientConn::new("127.0.0.1".into());
+
+        assert_eq!(client_conn.auth_challenge(), None);
+        assert_eq!(client_conn.auth_pubkey(), None);
+
+        let event = auth_event(&"challenge".into());
+        let result = client_conn.authenticate(&event, RELAY);
+
+        assert!(matches!(result, Err(Error::AuthFailure)));
+    }
+
+    #[test]
+    fn test_authenticate_when_already_authenticated() {
+        let mut client_conn = ClientConn::new("127.0.0.1".into());
+
+        assert_eq!(client_conn.auth_challenge(), None);
+        assert_eq!(client_conn.auth_pubkey(), None);
+
+        client_conn.generate_auth_challenge();
+
+        assert_ne!(client_conn.auth_challenge(), None);
+        assert_eq!(client_conn.auth_pubkey(), None);
+
+        let challenge = client_conn.auth_challenge().unwrap().clone();
+
+        let event = auth_event(&challenge);
+        let result = client_conn.authenticate(&event, RELAY);
+
+        assert!(matches!(result, Ok(())));
+        assert_eq!(client_conn.auth_challenge(), None);
+        assert_eq!(client_conn.auth_pubkey(), Some(&event.pubkey));
+
+        let event1 = auth_event(&challenge);
+        let result1 = client_conn.authenticate(&event1, RELAY);
+
+        assert!(matches!(result1, Ok(())));
+        assert_eq!(client_conn.auth_challenge(), None);
+        assert_eq!(client_conn.auth_pubkey(), Some(&event.pubkey));
+        assert_ne!(client_conn.auth_pubkey(), Some(&event1.pubkey));
+    }
+
+    #[test]
+    fn test_fail_to_authenticate_with_invalid_event() {
+        let mut client_conn = ClientConn::new("127.0.0.1".into());
+
+        assert_eq!(client_conn.auth_challenge(), None);
+        assert_eq!(client_conn.auth_pubkey(), None);
+
+        client_conn.generate_auth_challenge();
+
+        assert_ne!(client_conn.auth_challenge(), None);
+        assert_eq!(client_conn.auth_pubkey(), None);
+
+        let challenge = client_conn.auth_challenge().unwrap();
+        let mut event = auth_event(challenge);
+        event.sig = event.sig.chars().rev().collect::<String>();
+
+        let result = client_conn.authenticate(&event, RELAY);
+
+        assert!(matches!(result, Err(Error::AuthFailure)));
+    }
+
+    #[test]
+    fn test_fail_to_authenticate_with_invalid_event_kind() {
+        let mut client_conn = ClientConn::new("127.0.0.1".into());
+
+        assert_eq!(client_conn.auth_challenge(), None);
+        assert_eq!(client_conn.auth_pubkey(), None);
+
+        client_conn.generate_auth_challenge();
+
+        assert_ne!(client_conn.auth_challenge(), None);
+        assert_eq!(client_conn.auth_pubkey(), None);
+
+        let challenge = client_conn.auth_challenge().unwrap();
+        let event = auth_event_with_kind(challenge, 9999999999999999);
+
+        let result = client_conn.authenticate(&event, RELAY);
+
+        assert!(matches!(result, Err(Error::AuthFailure)));
+    }
+
+    #[test]
+    fn test_fail_to_authenticate_with_expired_timestamp() {
+        let mut client_conn = ClientConn::new("127.0.0.1".into());
+
+        assert_eq!(client_conn.auth_challenge(), None);
+        assert_eq!(client_conn.auth_pubkey(), None);
+
+        client_conn.generate_auth_challenge();
+
+        assert_ne!(client_conn.auth_challenge(), None);
+        assert_eq!(client_conn.auth_pubkey(), None);
+
+        let challenge = client_conn.auth_challenge().unwrap();
+        let event = auth_event_with_created_at(challenge, unix_time() - 1200); // 20 minutes
+
+        let result = client_conn.authenticate(&event, RELAY);
+
+        assert!(matches!(result, Err(Error::AuthFailure)));
+    }
+
+    #[test]
+    fn test_fail_to_authenticate_with_future_timestamp() {
+        let mut client_conn = ClientConn::new("127.0.0.1".into());
+
+        assert_eq!(client_conn.auth_challenge(), None);
+        assert_eq!(client_conn.auth_pubkey(), None);
+
+        client_conn.generate_auth_challenge();
+
+        assert_ne!(client_conn.auth_challenge(), None);
+        assert_eq!(client_conn.auth_pubkey(), None);
+
+        let challenge = client_conn.auth_challenge().unwrap();
+        let event = auth_event_with_created_at(challenge, unix_time() + 1200); // 20 minutes
+
+        let result = client_conn.authenticate(&event, RELAY);
+
+        assert!(matches!(result, Err(Error::AuthFailure)));
+    }
+
+    #[test]
+    fn test_fail_to_authenticate_without_tags() {
+        let mut client_conn = ClientConn::new("127.0.0.1".into());
+
+        assert_eq!(client_conn.auth_challenge(), None);
+        assert_eq!(client_conn.auth_pubkey(), None);
+
+        client_conn.generate_auth_challenge();
+
+        assert_ne!(client_conn.auth_challenge(), None);
+        assert_eq!(client_conn.auth_pubkey(), None);
+
+        let event = auth_event_without_tags();
+
+        let result = client_conn.authenticate(&event, RELAY);
+
+        assert!(matches!(result, Err(Error::AuthFailure)));
+    }
+
+    #[test]
+    fn test_fail_to_authenticate_without_challenge() {
+        let mut client_conn = ClientConn::new("127.0.0.1".into());
+
+        assert_eq!(client_conn.auth_challenge(), None);
+        assert_eq!(client_conn.auth_pubkey(), None);
+
+        client_conn.generate_auth_challenge();
+
+        assert_ne!(client_conn.auth_challenge(), None);
+        assert_eq!(client_conn.auth_pubkey(), None);
+
+        let event = auth_event_without_challenge();
+
+        let result = client_conn.authenticate(&event, RELAY);
+
+        assert!(matches!(result, Err(Error::AuthFailure)));
+    }
+
+    #[test]
+    fn test_fail_to_authenticate_without_relay() {
+        let mut client_conn = ClientConn::new("127.0.0.1".into());
+
+        assert_eq!(client_conn.auth_challenge(), None);
+        assert_eq!(client_conn.auth_pubkey(), None);
+
+        client_conn.generate_auth_challenge();
+
+        assert_ne!(client_conn.auth_challenge(), None);
+        assert_eq!(client_conn.auth_pubkey(), None);
+
+        let challenge = client_conn.auth_challenge().unwrap();
+        let event = auth_event_without_relay(challenge);
+
+        let result = client_conn.authenticate(&event, RELAY);
+
+        assert!(matches!(result, Err(Error::AuthFailure)));
+    }
+
+    #[test]
+    fn test_fail_to_authenticate_with_invalid_challenge() {
+        let mut client_conn = ClientConn::new("127.0.0.1".into());
+
+        assert_eq!(client_conn.auth_challenge(), None);
+        assert_eq!(client_conn.auth_pubkey(), None);
+
+        client_conn.generate_auth_challenge();
+
+        assert_ne!(client_conn.auth_challenge(), None);
+        assert_eq!(client_conn.auth_pubkey(), None);
+
+        let event = auth_event(&"invalid challenge".into());
+
+        let result = client_conn.authenticate(&event, RELAY);
+
+        assert!(matches!(result, Err(Error::AuthFailure)));
+    }
+
+    #[test]
+    fn test_fail_to_authenticate_with_invalid_relay() {
+        let mut client_conn = ClientConn::new("127.0.0.1".into());
+
+        assert_eq!(client_conn.auth_challenge(), None);
+        assert_eq!(client_conn.auth_pubkey(), None);
+
+        client_conn.generate_auth_challenge();
+
+        assert_ne!(client_conn.auth_challenge(), None);
+        assert_eq!(client_conn.auth_pubkey(), None);
+
+        let challenge = client_conn.auth_challenge().unwrap();
+        let event = auth_event_with_relay(challenge, &"xyz".into());
+
+        let result = client_conn.authenticate(&event, RELAY);
+
+        assert!(matches!(result, Err(Error::AuthFailure)));
+    }
+
+    fn auth_event(challenge: &String) -> Event {
+        create_auth_event(Some(challenge), Some(&RELAY.into()), 22242, unix_time())
+    }
+
+    fn auth_event_with_kind(challenge: &String, kind: u64) -> Event {
+        create_auth_event(Some(challenge), Some(&RELAY.into()), kind, unix_time())
+    }
+
+    fn auth_event_with_created_at(challenge: &String, created_at: u64) -> Event {
+        create_auth_event(Some(challenge), Some(&RELAY.into()), 22242, created_at)
+    }
+
+    fn auth_event_without_challenge() -> Event {
+        create_auth_event(None, Some(&RELAY.into()), 22242, unix_time())
+    }
+
+    fn auth_event_without_relay(challenge: &String) -> Event {
+        create_auth_event(Some(challenge), None, 22242, unix_time())
+    }
+
+    fn auth_event_without_tags() -> Event {
+        create_auth_event(None, None, 22242, unix_time())
+    }
+
+    fn auth_event_with_relay(challenge: &String, relay: &String) -> Event {
+        create_auth_event(Some(challenge), Some(relay), 22242, unix_time())
+    }
+
+    fn create_auth_event(
+        challenge: Option<&String>,
+        relay: Option<&String>,
+        kind: u64,
+        created_at: u64,
+    ) -> Event {
+        let secp = Secp256k1::new();
+        let key_pair = KeyPair::new(&secp, &mut rand::thread_rng());
+        let public_key = XOnlyPublicKey::from_keypair(&key_pair);
+
+        let mut tags: Vec<Vec<String>> = vec![];
+
+        if let Some(c) = challenge {
+            let tag = vec!["challenge".into(), c.into()];
+            tags.push(tag);
+        }
+
+        if let Some(r) = relay {
+            let tag = vec!["relay".into(), r.into()];
+            tags.push(tag);
+        }
+
+        let mut event = Event {
+            id: "0".to_owned(),
+            pubkey: public_key.to_hex(),
+            delegated_by: None,
+            created_at,
+            kind,
+            tags,
+            content: "".to_owned(),
+            sig: "0".to_owned(),
+            tagidx: None,
+        };
+
+        let c = event.to_canonical().unwrap();
+        let digest: sha256::Hash = sha256::Hash::hash(c.as_bytes());
+
+        let msg = secp256k1::Message::from_slice(digest.as_ref()).unwrap();
+        let sig = secp.sign_schnorr(&msg, &key_pair);
+
+        event.id = format!("{digest:x}");
+        event.sig = sig.to_hex();
+
+        event
+    }
+}

tests/integration_test.rs

@@ -0,0 +1,79 @@
+use anyhow::Result;
+use futures::SinkExt;
+use futures::StreamExt;
+use std::thread;
+use std::time::Duration;
+use tokio_tungstenite::connect_async;
+use tracing::info;
+mod common;
+
+#[tokio::test]
+async fn start_and_stop() -> Result<()> {
+    // this will be the common pattern for acquiring a new relay:
+    // start a fresh relay, on a port to-be-provided back to us:
+    let relay = common::start_relay()?;
+    // wait for the relay's webserver to start up and deliver a page:
+    common::wait_for_healthy_relay(&relay).await?;
+    let port = relay.port;
+    // just make sure we can startup and shut down.
+    // if we send a shutdown message before the server is listening,
+    // we will get a SendError.  Keep sending until someone is
+    // listening.
+    loop {
+        let shutdown_res = relay.shutdown_tx.send(());
+        match shutdown_res {
+            Ok(()) => {
+                break;
+            }
+            Err(_) => {
+                thread::sleep(Duration::from_millis(100));
+            }
+        }
+    }
+    // wait for relay to shutdown
+    let thread_join = relay.handle.join();
+    assert!(thread_join.is_ok());
+    // assert that port is now available.
+    assert!(common::port_is_available(port));
+    Ok(())
+}
+
+#[tokio::test]
+async fn relay_home_page() -> Result<()> {
+    // get a relay and wait for startup...
+    let relay = common::start_relay()?;
+    common::wait_for_healthy_relay(&relay).await?;
+    // tell relay to shutdown
+    let _res = relay.shutdown_tx.send(());
+    Ok(())
+}
+
+//#[tokio::test]
+// Still inwork
+async fn publish_test() -> Result<()> {
+    // get a relay and wait for startup
+    let relay = common::start_relay()?;
+    common::wait_for_healthy_relay(&relay).await?;
+    // open a non-secure websocket connection.
+    let (mut ws, _res) = connect_async(format!("ws://localhost:{}", relay.port)).await?;
+    // send a simple pre-made message
+    let simple_event = r#"["EVENT", {"content": "hello world","created_at": 1691239763,
+      "id":"f3ce6798d70e358213ebbeba4886bbdfacf1ecfd4f65ee5323ef5f404de32b86",
+      "kind": 1,
+      "pubkey": "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798",
+      "sig": "30ca29e8581eeee75bf838171dec818af5e6de2b74f5337de940f5cc91186534c0b20d6cf7ad1043a2c51dbd60b979447720a471d346322103c83f6cb66e4e98",
+      "tags": []}]"#;
+    ws.send(simple_event.into()).await?;
+    // get response from server, confirm it is an array with first element "OK"
+    let event_confirm = ws.next().await;
+    ws.close(None).await?;
+    info!("event confirmed: {:?}", event_confirm);
+    // open a new connection, and wait for some time to get the event.
+    let (mut sub_ws, _res) = connect_async(format!("ws://localhost:{}", relay.port)).await?;
+    let event_sub = r#"["REQ", "simple", {}]"#;
+    sub_ws.send(event_sub.into()).await?;
+    // read from subscription
+    let _ws_next = sub_ws.next().await;
+    let _res = relay.shutdown_tx.send(());
+    Ok(())
+}