clm-kernel 0.0.6

Cubical Logic Model (CLM) sovereign execution engine, CPN-VM, and Cordis spatiotemporal substrate
Documentation
//! Layer 0: Stateless Kenotic Codecs & Canonical Serialization
//! Canonical Path: kernel/clm_rust_core/src/layer0/codec.rs

use serde::Serialize;
use serde_json::Value;

/// Encode bytes to lowercase hexadecimal string.
pub fn to_hex(bytes: &[u8]) -> String {
    hex::encode(bytes)
}

/// Decode hexadecimal string into bytes.
pub fn from_hex(s: &str) -> Result<Vec<u8>, String> {
    hex::decode(s.trim()).map_err(|e| e.to_string())
}

/// Encode bytes to Base58 string (Bitcoin alphabet).
pub fn to_base58(bytes: &[u8]) -> String {
    const ALPHABET: &[u8; 58] = b"123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
    let mut zeroes = 0;
    while zeroes < bytes.len() && bytes[zeroes] == 0 {
        zeroes += 1;
    }

    let size = (bytes.len() - zeroes) * 138 / 100 + 1;
    let mut b58 = vec![0u8; size];

    for &b in &bytes[zeroes..] {
        let mut carry = b as u32;
        let mut i = 0;
        for it in b58.iter_mut().rev() {
            if carry == 0 && i >= size {
                break;
            }
            carry += 256 * (*it as u32);
            *it = (carry % 58) as u8;
            carry /= 58;
            i += 1;
        }
    }

    let mut it = 0;
    while it < b58.len() && b58[it] == 0 {
        it += 1;
    }

    let mut result = String::with_capacity(zeroes + (b58.len() - it));
    for _ in 0..zeroes {
        result.push('1');
    }
    for &digit in &b58[it..] {
        result.push(ALPHABET[digit as usize] as char);
    }
    result
}

/// Decode Base58 string into bytes.
pub fn from_base58(s: &str) -> Result<Vec<u8>, String> {
    const MAP: [i8; 128] = [
        -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
        -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
        -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
        -1, 0, 1, 2, 3, 4, 5, 6, 7, 8,-1,-1,-1,-1,-1,-1,
        -1, 9,10,11,12,13,14,15,16,-1,17,18,19,20,21,-1,
        22,23,24,25,26,27,28,29,30,31,32,-1,-1,-1,-1,-1,
        -1,33,34,35,36,37,38,39,40,41,42,43,-1,44,45,46,
        47,48,49,50,51,52,53,54,55,56,57,-1,-1,-1,-1,-1,
    ];

    let bytes = s.as_bytes();
    let mut zeroes = 0;
    while zeroes < bytes.len() && bytes[zeroes] == b'1' {
        zeroes += 1;
    }

    let size = bytes.len() * 733 / 1000 + 1;
    let mut b256 = vec![0u8; size];

    for &c in &bytes[zeroes..] {
        if c >= 128 || MAP[c as usize] == -1 {
            return Err(format!("Invalid Base58 character: {}", c as char));
        }
        let mut carry = MAP[c as usize] as u32;
        let mut i = 0;
        for it in b256.iter_mut().rev() {
            if carry == 0 && i >= size {
                break;
            }
            carry += 58 * (*it as u32);
            *it = (carry % 256) as u8;
            carry /= 256;
            i += 1;
        }
    }

    let mut it = 0;
    while it < b256.len() && b256[it] == 0 {
        it += 1;
    }

    let mut result = vec![0u8; zeroes];
    result.extend_from_slice(&b256[it..]);
    Ok(result)
}

/// Canonical JSON serialization with recursively sorted object keys.
pub fn canonical_json<T: Serialize>(value: &T) -> Result<String, String> {
    let raw = serde_json::to_value(value).map_err(|e| e.to_string())?;
    let sorted = sort_json_value(raw);
    serde_json::to_string(&sorted).map_err(|e| e.to_string())
}

fn sort_json_value(v: Value) -> Value {
    match v {
        Value::Object(map) => {
            let mut keys: Vec<String> = map.keys().cloned().collect();
            keys.sort();
            let mut sorted_map = serde_json::Map::new();
            for k in keys {
                if let Some(val) = map.get(&k) {
                    sorted_map.insert(k, sort_json_value(val.clone()));
                }
            }
            Value::Object(sorted_map)
        }
        Value::Array(arr) => Value::Array(arr.into_iter().map(sort_json_value).collect()),
        other => other,
    }
}

/// Canonical YAML serialization.
pub fn canonical_yaml<T: Serialize>(value: &T) -> Result<String, String> {
    serde_yaml::to_string(value).map_err(|e| e.to_string())
}