97 lines
2.2 KiB
Rust
97 lines
2.2 KiB
Rust
use crate::{Error, Pubkey, Result};
|
|
use serde_derive::{Deserialize, Serialize};
|
|
use std::hash::{Hash, Hasher};
|
|
|
|
/// Event is the struct used to represent a Nostr event
|
|
#[derive(Serialize, Deserialize, Debug, Clone)]
|
|
pub struct Event {
|
|
/// 32-bytes sha256 of the the serialized event data
|
|
pub id: EventId,
|
|
/// 32-bytes hex-encoded public key of the event creator
|
|
#[serde(rename = "pubkey")]
|
|
pub pubkey: Pubkey,
|
|
/// unix timestamp in seconds
|
|
pub created_at: u64,
|
|
/// integer
|
|
/// 0: NostrEvent
|
|
pub kind: u64,
|
|
/// Tags
|
|
pub tags: Vec<Vec<String>>,
|
|
/// arbitrary string
|
|
pub content: String,
|
|
/// 64-bytes signature of the sha256 hash of the serialized event data, which is the same as the "id" field
|
|
pub sig: String,
|
|
}
|
|
|
|
// Implement Hash trait
|
|
impl Hash for Event {
|
|
fn hash<H: Hasher>(&self, state: &mut H) {
|
|
self.id.0.hash(state);
|
|
}
|
|
}
|
|
|
|
impl PartialEq for Event {
|
|
fn eq(&self, other: &Self) -> bool {
|
|
self.id == other.id
|
|
}
|
|
}
|
|
|
|
impl Eq for Event {}
|
|
|
|
impl Event {
|
|
pub fn from_json(s: &str) -> Result<Self> {
|
|
serde_json::from_str(s).map_err(Into::into)
|
|
}
|
|
|
|
pub fn verify(&self) -> Result<Self> {
|
|
return Err(Error::InvalidSignature);
|
|
}
|
|
|
|
/// This is just for serde sanity checking
|
|
#[allow(dead_code)]
|
|
pub(crate) fn new_dummy(
|
|
id: &str,
|
|
pubkey: &str,
|
|
created_at: u64,
|
|
kind: u64,
|
|
tags: Vec<Vec<String>>,
|
|
content: &str,
|
|
sig: &str,
|
|
) -> Result<Self> {
|
|
let event = Event {
|
|
id: id.to_string().into(),
|
|
pubkey: pubkey.to_string().into(),
|
|
created_at,
|
|
kind,
|
|
tags,
|
|
content: content.to_string(),
|
|
sig: sig.to_string(),
|
|
};
|
|
|
|
event.verify()
|
|
}
|
|
}
|
|
|
|
impl std::str::FromStr for Event {
|
|
type Err = Error;
|
|
|
|
fn from_str(s: &str) -> Result<Self> {
|
|
Event::from_json(s)
|
|
}
|
|
}
|
|
|
|
#[derive(Serialize, Deserialize, Debug, Eq, PartialEq, Clone, Hash)]
|
|
pub struct EventId(String);
|
|
|
|
impl From<String> for EventId {
|
|
fn from(s: String) -> Self {
|
|
EventId(s)
|
|
}
|
|
}
|
|
|
|
impl From<EventId> for String {
|
|
fn from(evid: EventId) -> Self {
|
|
evid.0
|
|
}
|
|
}
|