From 72f8a1aa5c2c1e7ffba2cd897f5c992febc44674 Mon Sep 17 00:00:00 2001 From: Greg Heartsfield Date: Sun, 16 Oct 2022 15:25:06 -0500 Subject: [PATCH] feat(NIP-26): allow searches for delegated public keys Implements core NIP-26 delegated event functionality. Events can include a `delegation` tag that provides a signature and restrictions on which events can be delegated. Notable points on the implementation so far: * Schema has been upgraded to include an index and new column. * Basic rune parsing/evaluation to implement the example event in the NIP, but no more. * No special logic for deletion. * No migration logic for determining delegated authors for already-stored events. --- Cargo.lock | 1 + Cargo.toml | 1 + README.md | 1 + src/db.rs | 22 ++- src/delegation.rs | 416 ++++++++++++++++++++++++++++++++++++++++++++ src/error.rs | 2 + src/event.rs | 81 ++++++++- src/info.rs | 2 +- src/lib.rs | 1 + src/schema.rs | 27 ++- src/subscription.rs | 24 ++- 11 files changed, 568 insertions(+), 10 deletions(-) create mode 100644 src/delegation.rs diff --git a/Cargo.lock b/Cargo.lock index 0fac8fb..9bb7abf 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1042,6 +1042,7 @@ dependencies = [ "r2d2", "r2d2_sqlite", "rand 0.8.5", + "regex", "rusqlite", "secp256k1", "serde", diff --git a/Cargo.toml b/Cargo.toml index bb1588e..fc44f21 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -32,6 +32,7 @@ http = { version = "0.2" } parse_duration = "2" rand = "0.8" const_format = "0.2.28" +regex = "1" [dev-dependencies] anyhow = "1" diff --git a/README.md b/README.md index 62c62c6..dfc7814 100644 --- a/README.md +++ b/README.md @@ -27,6 +27,7 @@ mirrored on [GitHub](https://github.com/scsibug/nostr-rs-relay). - [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-22: [Event `created_at` limits](https://github.com/nostr-protocol/nips/blob/master/22.md) (_future-dated events only_) +- [x] NIP-26: [Event Delegation](https://github.com/nostr-protocol/nips/blob/master/26.md) ## Quick Start diff --git a/src/db.rs b/src/db.rs index ba861c4..6c9b1d8 100644 --- a/src/db.rs +++ b/src/db.rs @@ -142,12 +142,15 @@ pub async fn db_writer( if next_event.is_none() { break; } + // track if an event write occurred; this is used to + // update the rate limiter let mut event_write = false; let subm_event = next_event.unwrap(); let event = subm_event.event; let notice_tx = subm_event.notice_tx; // check if this event is authorized. if let Some(allowed_addrs) = whitelist { + // TODO: incorporate delegated pubkeys // if the event address is not in allowed_addrs. if !allowed_addrs.contains(&event.pubkey) { info!( @@ -284,12 +287,13 @@ pub fn write_event(conn: &mut PooledConnection, e: &Event) -> Result { let tx = conn.transaction()?; // get relevant fields from event and convert to blobs. let id_blob = hex::decode(&e.id).ok(); - let pubkey_blob = hex::decode(&e.pubkey).ok(); + let pubkey_blob: Option> = hex::decode(&e.pubkey).ok(); + let delegator_blob: Option> = 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 mut ins_count = tx.execute( - "INSERT OR IGNORE INTO event (event_hash, created_at, kind, author, content, first_seen, hidden) VALUES (?1, ?2, ?3, ?4, ?5, strftime('%s','now'), FALSE);", - params![id_blob, e.created_at, e.kind, pubkey_blob, event_str] + "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 { // if the event was a duplicate, no need to insert event or @@ -439,16 +443,22 @@ fn query_from_filter(f: &ReqFilter) -> (String, Vec>) { for auth in authvec { match hex_range(auth) { Some(HexSearch::Exact(ex)) => { - auth_searches.push("author=?".to_owned()); + auth_searches.push("author=? OR delegated_by=?".to_owned()); + params.push(Box::new(ex.clone())); params.push(Box::new(ex)); } Some(HexSearch::Range(lower, upper)) => { - auth_searches.push("(author>? AND author? AND author? AND delegated_by { - auth_searches.push("author>?".to_owned()); + auth_searches.push("author>? OR delegated_by>?".to_owned()); + params.push(Box::new(lower.clone())); params.push(Box::new(lower)); } None => { diff --git a/src/delegation.rs b/src/delegation.rs new file mode 100644 index 0000000..2b056be --- /dev/null +++ b/src/delegation.rs @@ -0,0 +1,416 @@ +//! 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 = 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 { + 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 { + 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(crate) conditions: Vec, +} + +impl ConditionQuery { + 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. +pub fn validate_delegation( + delegator: &str, + delegatee: &str, + cond_query: &str, + sigstr: &str, +) -> Option { + // 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::().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(crate) field: Field, + pub(crate) operator: Operator, + pub(crate) values: Vec, +} + +impl Condition { + /// Check if this condition allows the given event to be delegated + 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 { + // 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::().ok()?; + let operator = caps.get(2)?.as_str().parse::().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::().ok()) + .collect::>>()?; + // 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 { + // 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::()?; + assert_eq!(parsed, empty_cq); + Ok(()) + } + + // parse field 'kind' + #[test] + fn test_kind_field_parse() -> Result<()> { + let field = "kind".parse::()?; + assert_eq!(field, Field::Kind); + Ok(()) + } + // parse field 'created_at' + #[test] + fn test_created_at_field_parse() -> Result<()> { + let field = "created_at".parse::()?; + assert_eq!(field, Field::CreatedAt); + Ok(()) + } + // parse unknown field + #[test] + fn unknown_field_parse() { + let field = "unk".parse::(); + 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::()?; + 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::()?; + 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::()?; + 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![1665867123], + }, + ], + }; + let parsed = + "kind>10000&kind<20000&kind!10001&created_at<1665867123".parse::()?; + assert_eq!(parsed, cq); + Ok(()) + } + 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, + } + } + // 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 = 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 = 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 = 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)); + } +} diff --git a/src/error.rs b/src/error.rs index 5a0c992..bca9fc6 100644 --- a/src/error.rs +++ b/src/error.rs @@ -50,6 +50,8 @@ pub enum Error { HyperError(hyper::Error), #[error("Hex encoding error")] HexError(hex::FromHexError), + #[error("Delegation parse error")] + DelegationParseError, #[error("Unknown/Undocumented")] UnknownError, } diff --git a/src/event.rs b/src/event.rs index 2366e42..60d5cb1 100644 --- a/src/event.rs +++ b/src/event.rs @@ -1,4 +1,5 @@ //! Event parsing and validation +use crate::delegation::validate_delegation; use crate::error::Error::*; use crate::error::Result; use crate::nip05; @@ -31,6 +32,8 @@ pub struct EventCmd { pub struct Event { pub id: String, pub(crate) pubkey: String, + #[serde(skip)] + pub(crate) delegated_by: Option, pub(crate) created_at: u64, pub(crate) kind: u64, #[serde(deserialize_with = "tag_from_string")] @@ -83,6 +86,7 @@ impl From for Result { } else if ec.event.is_valid() { let mut e = ec.event; e.build_index(); + e.update_delegation(); Ok(e) } else { Err(EventInvalid) @@ -110,6 +114,50 @@ 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 + pub fn delegated_author(&self) -> Option { + // is there a delegation tag? + let delegation_tag: Vec = self + .tags + .iter() + .filter(|x| x.len() == 4) + .filter(|x| x.get(0).unwrap() == "delegation") + .take(1) + .next()? + .to_vec(); // 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 + fn update_delegation(&mut self) { + self.delegated_by = self.delegated_author(); + } /// Build an event tag index fn build_index(&mut self) { // if there are no tags; just leave the index as None @@ -145,7 +193,7 @@ impl Event { self.pubkey.chars().take(8).collect() } - /// Retrieve tag values + /// Retrieve tag initial values across all tags matching the name pub fn tag_values_by_name(&self, tag_name: &str) -> Vec { self.tags .iter() @@ -269,6 +317,7 @@ mod tests { Event { id: "0".to_owned(), pubkey: "0".to_owned(), + delegated_by: None, created_at: 0, kind: 0, tags: vec![], @@ -350,6 +399,7 @@ mod tests { let e = Event { id: "999".to_owned(), pubkey: "012345".to_owned(), + delegated_by: None, created_at: 501234, kind: 1, tags: vec![], @@ -367,6 +417,7 @@ mod tests { let e = Event { id: "999".to_owned(), pubkey: "012345".to_owned(), + delegated_by: None, created_at: 501234, kind: 1, tags: vec![ @@ -388,11 +439,39 @@ 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: 501234, + 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(), + delegated_by: None, created_at: 501234, kind: 1, tags: vec![ diff --git a/src/info.rs b/src/info.rs index c828ccd..4a37ae4 100644 --- a/src/info.rs +++ b/src/info.rs @@ -35,7 +35,7 @@ impl From for RelayInfo { description: i.description, pubkey: i.pubkey, contact: i.contact, - supported_nips: Some(vec![1, 2, 9, 11, 12, 15, 16, 22]), + supported_nips: Some(vec![1, 2, 9, 11, 12, 15, 16, 22, 26]), software: Some("https://git.sr.ht/~gheartsfield/nostr-rs-relay".to_owned()), version: CARGO_PKG_VERSION.map(|x| x.to_owned()), } diff --git a/src/lib.rs b/src/lib.rs index 885f155..dc00507 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -2,6 +2,7 @@ pub mod close; pub mod config; pub mod conn; pub mod db; +pub mod delegation; pub mod error; pub mod event; pub mod hexrange; diff --git a/src/schema.rs b/src/schema.rs index 8f5638e..a7a605d 100644 --- a/src/schema.rs +++ b/src/schema.rs @@ -20,7 +20,7 @@ pragma mmap_size = 536870912; -- 512MB of mmap "##; /// Latest database version -pub const DB_VERSION: usize = 6; +pub const DB_VERSION: usize = 7; /// Schema definition const INIT_SQL: &str = formatcp!( @@ -40,6 +40,7 @@ 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 +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 @@ -49,6 +50,7 @@ content TEXT NOT NULL -- serialized json of event object 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 delegated_by_index ON event(delegated_by); CREATE INDEX IF NOT EXISTS kind_index ON event(kind); -- Tag Table @@ -152,6 +154,9 @@ pub fn upgrade_db(conn: &mut PooledConnection) -> Result<()> { 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 == DB_VERSION { info!( "All migration scripts completed successfully. Welcome to v{}.", @@ -348,3 +353,23 @@ fn mig_5_to_6(conn: &mut PooledConnection) -> Result { info!("vacuumed DB after tags rebuild in {:?}", start.elapsed()); Ok(6) } + +fn mig_6_to_7(conn: &mut PooledConnection) -> Result { + info!("database schema needs update from 6->7"); + // only change is adding a hidden column to events. + 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 failed: {}", err); + panic!("database could not be upgraded"); + } + } + Ok(7) +} diff --git a/src/subscription.rs b/src/subscription.rs index 9fe4dba..ecadb11 100644 --- a/src/subscription.rs +++ b/src/subscription.rs @@ -217,6 +217,17 @@ impl ReqFilter { .unwrap_or(true) } + fn delegated_authors_match(&self, event: &Event) -> bool { + if let Some(delegated_pubkey) = &event.delegated_by { + self.authors + .as_ref() + .map(|vs| prefix_match(vs, delegated_pubkey)) + .unwrap_or(true) + } else { + false + } + } + fn tag_match(&self, event: &Event) -> bool { // get the hashset from the filter. if let Some(map) = &self.tags { @@ -248,7 +259,7 @@ impl ReqFilter { && self.since.map(|t| event.created_at > t).unwrap_or(true) && self.until.map(|t| event.created_at < t).unwrap_or(true) && 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 } @@ -308,6 +319,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 +338,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 +357,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 +377,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 +401,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 +423,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 +442,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 +461,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 +480,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(), @@ -479,6 +499,7 @@ mod tests { let e = Event { id: "123".to_owned(), pubkey: "bcd".to_owned(), + delegated_by: None, created_at: 0, kind: 0, tags: Vec::new(), @@ -497,6 +518,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(),