use serde::{Deserialize, Serialize};
pub const SEED_KEY: &str = "cg.studio.seed";
pub const NAMES_KEY: &str = "cg.studio.particles";
pub const SIGNALS_KEY: &str = "cg.studio.signals";
pub const SIGNAL_SEQ_KEY: &str = "cg.studio.signal_seq";
pub const INTENTS_KEY: &str = "cg.studio.intents";
pub const INTENT_SEQ_KEY: &str = "cg.studio.intent_seq";
pub const DOMAIN: &str = "cybergraph.studio";
pub const HRP: &str = "cyber";
pub const DEFAULT_COIN: &str = "CYB";
fn ls_get(key: &str) -> Option<String> {
web_sys::window()
.and_then(|w| w.local_storage().ok().flatten())
.and_then(|ls| ls.get_item(key).ok().flatten())
}
fn ls_set(key: &str, raw: &str) {
if let Some(ls) = web_sys::window().and_then(|w| w.local_storage().ok().flatten()) {
let _ = ls.set_item(key, raw);
}
}
fn load_json<T: for<'de> Deserialize<'de>>(key: &str) -> Vec<T> {
ls_get(key)
.and_then(|raw| serde_json::from_str(&raw).ok())
.unwrap_or_default()
}
fn save_json<T: Serialize>(key: &str, list: &[T]) {
if let Ok(raw) = serde_json::to_string(list) {
ls_set(key, &raw);
}
}
fn next_id(seq_key: &str, prefix: &str) -> String {
let n: u64 = ls_get(seq_key).and_then(|s| s.parse().ok()).unwrap_or(0) + 1;
ls_set(seq_key, &n.to_string());
format!("{prefix}-{n}")
}
fn hex(bytes: &[u8]) -> String {
bytes.iter().map(|b| format!("{b:02x}")).collect()
}
fn unhex(s: &str) -> Option<Vec<u8>> {
if s.len() % 2 != 0 || !s.is_ascii() {
return None;
}
(0..s.len() / 2)
.map(|i| u8::from_str_radix(&s[i * 2..i * 2 + 2], 16).ok())
.collect()
}
pub fn is_particle(s: &str) -> bool {
s.len() == 64 && s.chars().all(|c| c.is_ascii_hexdigit())
}
#[derive(Clone, Debug, PartialEq)]
pub struct NeuronInfo {
pub bech32: String,
pub pubkey_hex: String,
pub native_hex: String,
}
fn load_or_create_entropy() -> [u8; 32] {
if let Some(saved) = ls_get(SEED_KEY).and_then(|s| unhex(&s)) {
if let Ok(e) = <[u8; 32]>::try_from(saved) {
return e;
}
}
let mut e = [0u8; 32];
getrandom::getrandom(&mut e).expect("os entropy");
ls_set(SEED_KEY, &hex(&e));
e
}
fn domain_key() -> mudra::domain::DomainKey {
let entropy = load_or_create_entropy();
mudra::domain::DomainKey::derive(&entropy, DOMAIN, HRP).expect("domain key derivation")
}
pub fn neuron() -> NeuronInfo {
let key = domain_key();
NeuronInfo {
bech32: key.bech32.clone(),
pubkey_hex: hex(&key.pubkey),
native_hex: hex(&key.native),
}
}
pub fn particle_of(bytes: &[u8]) -> String {
hex(hemera::hash(bytes).as_bytes())
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Named {
pub particle: String,
pub name: String,
pub kind: String,
#[serde(default)]
pub size: u64,
}
pub fn load_names() -> Vec<Named> {
load_json(NAMES_KEY)
}
pub fn remember(particle: &str, name: &str, kind: &str, size: u64) {
let mut names = load_names();
if !names.iter().any(|n| n.particle == particle) {
names.push(Named {
particle: particle.to_string(),
name: name.to_string(),
kind: kind.to_string(),
size,
});
save_json(NAMES_KEY, &names);
}
}
pub fn find_by_name(name: &str) -> Option<Named> {
let lower = name.trim().to_lowercase();
load_names().into_iter().find(|n| n.name.to_lowercase() == lower)
}
pub fn short(p: &str) -> String {
if p.len() > 14 && p.is_ascii() {
format!("{}โฆ{}", &p[..6], &p[p.len() - 4..])
} else {
p.to_string()
}
}
pub fn name_of(particle: &str) -> String {
load_names()
.into_iter()
.find(|n| n.particle == particle)
.map(|n| n.name)
.unwrap_or_else(|| short(particle))
}
#[derive(Clone, Debug, PartialEq)]
pub enum Resolved {
Empty,
Raw(String),
Known(Named),
NewText(String),
}
pub fn resolve(text: &str) -> Resolved {
let t = text.trim();
if t.is_empty() {
return Resolved::Empty;
}
if is_particle(t) {
return Resolved::Raw(t.to_lowercase());
}
if let Some(n) = find_by_name(t) {
return Resolved::Known(n);
}
Resolved::NewText(particle_of(t.as_bytes()))
}
pub fn resolve_and_remember(text: &str) -> Option<String> {
match resolve(text) {
Resolved::Empty => None,
Resolved::Raw(p) => Some(p),
Resolved::Known(n) => Some(n.particle),
Resolved::NewText(p) => {
let t = text.trim();
remember(&p, t, "text", t.len() as u64);
Some(p)
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Link {
pub from: String,
pub to: String,
pub coin: String,
pub amount: u64,
pub valence: i8,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Leg {
pub subject: String,
#[serde(flatten)]
pub link: Link,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Seal {
pub subject: String,
pub pubkey_hex: String,
pub sig_hex: String,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Signal {
pub id: String,
pub state: String,
pub legs: Vec<Leg>,
#[serde(default)]
pub body_particle: String,
#[serde(default)]
pub seals: Vec<Seal>,
}
impl Signal {
pub fn subjects(&self) -> Vec<String> {
let mut out: Vec<String> = Vec::new();
for l in &self.legs {
if !out.contains(&l.subject) {
out.push(l.subject.clone());
}
}
out
}
pub fn total_box(&self) -> Vec<(String, u64)> {
let mut out: Vec<(String, u64)> = Vec::new();
for l in &self.legs {
match out.iter_mut().find(|(c, _)| *c == l.link.coin) {
Some((_, a)) => *a = a.saturating_add(l.link.amount),
None => out.push((l.link.coin.clone(), l.link.amount)),
}
}
out
}
}
pub fn load_signals() -> Vec<Signal> {
load_json(SIGNALS_KEY)
}
fn save_signals(list: &[Signal]) {
save_json(SIGNALS_KEY, list);
}
pub fn find_signal(id: &str) -> Option<Signal> {
load_signals().into_iter().find(|s| s.id == id)
}
pub fn committed_signals() -> Vec<Signal> {
let mut v: Vec<Signal> = load_signals()
.into_iter()
.filter(|s| s.state == "committed")
.collect();
v.reverse();
v
}
pub fn draft() -> Option<Signal> {
load_signals().into_iter().find(|s| s.state == "draft")
}
pub fn draft_link(link: Link) -> String {
let mut signals = load_signals();
let leg = Leg {
subject: neuron().bech32,
link,
};
let id = match signals.iter_mut().find(|s| s.state == "draft") {
Some(s) => {
s.legs.push(leg);
s.id.clone()
}
None => {
let id = next_id(SIGNAL_SEQ_KEY, "sg");
signals.push(Signal {
id: id.clone(),
state: "draft".into(),
legs: vec![leg],
body_particle: String::new(),
seals: Vec::new(),
});
id
}
};
save_signals(&signals);
id
}
pub fn remove_draft_link(index: usize) {
let mut signals = load_signals();
if let Some(s) = signals.iter_mut().find(|s| s.state == "draft") {
if index < s.legs.len() {
s.legs.remove(index);
}
}
save_signals(&signals);
}
pub fn canonical_body(legs: &[Leg]) -> String {
legs.iter()
.map(|l| {
format!(
"{}|{}|{}|{}|{}|{}",
l.subject, l.link.from, l.link.to, l.link.coin, l.link.amount, l.link.valence
)
})
.collect::<Vec<_>>()
.join("\n")
}
pub fn commit_signal(id: &str) -> Result<(), String> {
let mut signals = load_signals();
let Some(s) = signals.iter_mut().find(|s| s.id == id) else {
return Err("signal not found".into());
};
if s.state != "draft" {
return Err("already committed".into());
}
if s.legs.is_empty() {
return Err("empty signal: add at least one link".into());
}
let key = domain_key();
if s.legs.iter().any(|l| l.subject != key.bech32) {
return Err("a link is authored by another neuron: its signature is missing".into());
}
let body = canonical_body(&s.legs);
s.body_particle = particle_of(body.as_bytes());
s.seals = vec![Seal {
subject: key.bech32.clone(),
pubkey_hex: hex(&key.pubkey),
sig_hex: hex(&mudra::claim::sign_arbitrary(
key.signing_key(),
&key.bech32,
body.as_bytes(),
)),
}];
s.state = "committed".into();
save_signals(&signals);
Ok(())
}
pub fn verify_signal(id: &str) -> Result<(), String> {
let Some(s) = find_signal(id) else {
return Err("signal not found".into());
};
verify_stored_signal(&s)
}
fn verify_seal(subject: &str, pubkey_hex: &str, sig_hex: &str, body: &[u8]) -> Result<(), String> {
let pubkey: [u8; 33] = unhex(pubkey_hex)
.and_then(|v| v.try_into().ok())
.ok_or("bad pubkey encoding")?;
match mudra::cosmos::address(&pubkey, HRP) {
Ok(addr) if addr == subject => {}
Ok(_) => return Err("neuron does not match pubkey".into()),
Err(e) => return Err(format!("address: {e}")),
}
let sig: [u8; 64] = unhex(sig_hex)
.and_then(|v| v.try_into().ok())
.ok_or("bad signature encoding")?;
if mudra::claim::verify_arbitrary(&pubkey, subject, body, &sig) {
Ok(())
} else {
Err("signature invalid".into())
}
}
pub fn verify_stored_signal(s: &Signal) -> Result<(), String> {
if s.state != "committed" {
return Err("not committed".into());
}
let body = canonical_body(&s.legs);
if particle_of(body.as_bytes()) != s.body_particle {
return Err("body particle mismatch".into());
}
for subject in s.subjects() {
let Some(seal) = s.seals.iter().find(|x| x.subject == subject) else {
return Err(format!("no signature from {subject}"));
};
verify_seal(&seal.subject, &seal.pubkey_hex, &seal.sig_hex, body.as_bytes())?;
}
Ok(())
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Intent {
pub id: String,
pub neuron: String,
pub scope: String,
pub sealer: String,
pub offer_coin: String,
pub offer_amount: u64,
pub scope_particle: String,
pub pubkey_hex: String,
pub sig_hex: String,
pub state: String,
#[serde(default)]
pub sealed_by: String,
}
pub fn load_intents() -> Vec<Intent> {
load_json(INTENTS_KEY)
}
fn canonical_scope(scope: &str, sealer: &str, coin: &str, amount: u64) -> String {
format!("{scope}|{sealer}|{coin}|{amount}")
}
fn intent_message(neuron: &str, scope_particle: &str) -> String {
format!("intent|{neuron}|{scope_particle}")
}
pub fn declare_intent(scope: &str, sealer: &str, coin: &str, amount: u64) -> Result<String, String> {
let scope = scope.trim();
if scope.is_empty() {
return Err("write the scope: what is to be done".into());
}
let key = domain_key();
let scope_particle = particle_of(canonical_scope(scope, sealer, coin, amount).as_bytes());
let msg = intent_message(&key.bech32, &scope_particle);
let id = next_id(INTENT_SEQ_KEY, "in");
let mut intents = load_intents();
intents.push(Intent {
id: id.clone(),
neuron: key.bech32.clone(),
scope: scope.to_string(),
sealer: sealer.to_string(),
offer_coin: coin.to_string(),
offer_amount: amount,
scope_particle,
pubkey_hex: hex(&key.pubkey),
sig_hex: hex(&mudra::claim::sign_arbitrary(
key.signing_key(),
&key.bech32,
msg.as_bytes(),
)),
state: "open".into(),
sealed_by: String::new(),
});
save_json(INTENTS_KEY, &intents);
Ok(id)
}
pub fn verify_intent(i: &Intent) -> Result<(), String> {
let scope = canonical_scope(&i.scope, &i.sealer, &i.offer_coin, i.offer_amount);
if particle_of(scope.as_bytes()) != i.scope_particle {
return Err("scope particle mismatch".into());
}
let msg = intent_message(&i.neuron, &i.scope_particle);
verify_seal(&i.neuron, &i.pubkey_hex, &i.sig_hex, msg.as_bytes())
}
pub fn seal_intent(intent_id: &str, signal_id: &str) -> Result<(), String> {
let Some(signal) = find_signal(signal_id) else {
return Err("signal not found".into());
};
if signal.state != "committed" {
return Err("only a committed signal seals an intent".into());
}
let mut intents = load_intents();
let Some(i) = intents.iter_mut().find(|i| i.id == intent_id) else {
return Err("intent not found".into());
};
if i.state != "open" {
return Err("an intent seals once".into());
}
if i.sealer == "me" && !signal.subjects().contains(&i.neuron) {
return Err("this intent admits only its declarer as sealer".into());
}
i.state = "sealed".into();
i.sealed_by = signal_id.to_string();
save_json(INTENTS_KEY, &intents);
Ok(())
}