|
|
|
|
| use serde::{Deserialize, Serialize};
|
| use std::collections::HashMap;
|
| use uuid::Uuid;
|
|
|
|
|
| #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
|
| pub struct Instruction {
|
| pub protocol_version: String,
|
| pub instruction_id: String,
|
| pub symbol: String,
|
| pub target_runtime: String,
|
| pub verb: String,
|
| pub arguments: HashMap<String, serde_json::Value>,
|
| pub timestamp: u64,
|
| pub instruction_hash: String,
|
| pub capability_id: String,
|
| #[serde(skip_serializing_if = "Option::is_none")]
|
| pub source_cell_id: Option<String>,
|
| }
|
|
|
| impl Instruction {
|
|
|
| pub fn new(
|
| symbol: String,
|
| target_runtime: String,
|
| verb: String,
|
| arguments: HashMap<String, serde_json::Value>,
|
| capability_id: String,
|
| ) -> Self {
|
| let timestamp = std::time::SystemTime::now()
|
| .duration_since(std::time::UNIX_EPOCH)
|
| .unwrap()
|
| .as_secs();
|
|
|
| let instruction_id = Uuid::new_v4().to_string();
|
| let instruction_hash = Self::compute_hash(&symbol, &target_runtime, &verb, &arguments);
|
|
|
| Instruction {
|
| protocol_version: "1.0.0".to_string(),
|
| instruction_id,
|
| symbol,
|
| target_runtime,
|
| verb,
|
| arguments,
|
| timestamp,
|
| instruction_hash,
|
| capability_id,
|
| source_cell_id: None,
|
| }
|
| }
|
|
|
|
|
| fn compute_hash(symbol: &str, runtime: &str, verb: &str, args: &HashMap<String, serde_json::Value>) -> String {
|
| use sha2::{Sha256, Digest};
|
|
|
| let canonical = serde_json::json!({
|
| "symbol": symbol,
|
| "runtime": runtime,
|
| "verb": verb,
|
| "arguments": args
|
| });
|
|
|
| let mut hasher = Sha256::new();
|
| hasher.update(canonical.to_string().as_bytes());
|
| format!("{:x}", hasher.finalize())
|
| }
|
|
|
|
|
| pub fn verify_hash(&self) -> bool {
|
| let computed = Self::compute_hash(&self.symbol, &self.target_runtime, &self.verb, &self.arguments);
|
| computed == self.instruction_hash
|
| }
|
|
|
|
|
| pub fn with_source_cell(mut self, cell_id: String) -> Self {
|
| self.source_cell_id = Some(cell_id);
|
| self
|
| }
|
| }
|
|
|
| #[cfg(test)]
|
| mod tests {
|
| use super::*;
|
|
|
| #[test]
|
| fn test_instruction_creation() {
|
| let mut args = HashMap::new();
|
| args.insert("fn".to_string(), serde_json::json!("FreqAnchor1618"));
|
|
|
| let instr = Instruction::new(
|
| "⚡".to_string(),
|
| "holyc".to_string(),
|
| "Execute".to_string(),
|
| args,
|
| "capa_001".to_string(),
|
| );
|
|
|
| assert_eq!(instr.protocol_version, "1.0.0");
|
| assert_eq!(instr.symbol, "⚡");
|
| assert_eq!(instr.target_runtime, "holyc");
|
| assert!(instr.verify_hash());
|
| }
|
|
|
| #[test]
|
| fn test_instruction_hash_determinism() {
|
| let mut args1 = HashMap::new();
|
| args1.insert("fn".to_string(), serde_json::json!("FreqAnchor1618"));
|
|
|
| let mut args2 = HashMap::new();
|
| args2.insert("fn".to_string(), serde_json::json!("FreqAnchor1618"));
|
|
|
| let instr1 = Instruction::new(
|
| "⚡".to_string(),
|
| "holyc".to_string(),
|
| "Execute".to_string(),
|
| args1,
|
| "capa_001".to_string(),
|
| );
|
|
|
| let instr2 = Instruction::new(
|
| "⚡".to_string(),
|
| "holyc".to_string(),
|
| "Execute".to_string(),
|
| args2,
|
| "capa_001".to_string(),
|
| );
|
|
|
|
|
|
|
| assert_eq!(instr1.instruction_hash, instr2.instruction_hash);
|
| }
|
| }
|
|
|
|
|
