agent-ask 0.1.0

//! Ed25519 keypair + did:key helpers (mirror of `src/identity.ts`).

use base64::{engine::general_purpose::STANDARD as B64, Engine as _};
use ed25519_dalek::{Signer, SigningKey, Verifier, VerifyingKey, SECRET_KEY_LENGTH};
use rand::rngs::OsRng;

use crate::error::Error;

const ED25519_MULTICODEC: [u8; 2] = [0xED, 0x01];

#[derive(Debug, Clone)]
pub struct Keypair {
    pub private_key: [u8; SECRET_KEY_LENGTH],
    pub public_key: [u8; 32],
    pub did: String,
}

pub fn generate_keypair() -> Keypair {
    let signing = SigningKey::generate(&mut OsRng);
    let verifying = signing.verifying_key();
    let pub_key = verifying.to_bytes();
    Keypair {
        private_key: signing.to_bytes(),
        public_key: pub_key,
        did: did_from_pubkey(&pub_key).expect("32-byte pubkey"),
    }
}

pub fn did_from_pubkey(pubkey: &[u8]) -> Result<String, Error> {
    if pubkey.len() != 32 {
        return Err(Error::Invalid("pubkey must be 32 bytes".into()));
    }
    let mut buf = Vec::with_capacity(34);
    buf.extend_from_slice(&ED25519_MULTICODEC);
    buf.extend_from_slice(pubkey);
    Ok(format!("did:key:z{}", bs58::encode(&buf).into_string()))
}

pub fn pubkey_from_did(did: &str) -> Result<[u8; 32], Error> {
    if !did.starts_with("did:key:") {
        return Err(Error::Invalid("not a did:key".into()));
    }
    let multibase = &did["did:key:".len()..];
    let Some(rest) = multibase.strip_prefix('z') else {
        return Err(Error::Invalid("did:key must use base58btc (z-prefix)".into()));
    };
    let decoded = bs58::decode(rest)
        .into_vec()
        .map_err(|e| Error::Invalid(format!("base58: {e}")))?;
    if decoded.len() != 34 || decoded[0] != 0xED || decoded[1] != 0x01 {
        return Err(Error::Invalid("did:key multicodec is not ed25519-pub".into()));
    }
    let mut out = [0u8; 32];
    out.copy_from_slice(&decoded[2..]);
    Ok(out)
}

pub fn sign(message: &[u8], private_key: &[u8; SECRET_KEY_LENGTH]) -> [u8; 64] {
    SigningKey::from_bytes(private_key).sign(message).to_bytes()
}

pub fn verify_sig(sig: &[u8], message: &[u8], public_key: &[u8; 32]) -> bool {
    let Ok(vk) = VerifyingKey::from_bytes(public_key) else {
        return false;
    };
    let Ok(sig_arr) = <[u8; 64]>::try_from(sig) else {
        return false;
    };
    vk.verify(message, &ed25519_dalek::Signature::from_bytes(&sig_arr))
        .is_ok()
}

pub fn to_base64(bytes: &[u8]) -> String {
    B64.encode(bytes)
}

pub fn from_base64(s: &str) -> Result<Vec<u8>, Error> {
    B64.decode(s).map_err(|e| Error::Invalid(format!("base64: {e}")))
}