clm-kernel 0.0.22

Cubical Logic Model (CLM) sovereign execution engine, CPN-VM, and Cordis spatiotemporal substrate
Documentation
use crate::layer0::mcard_record::MCardRecord;
use rusqlite::functions::FunctionFlags;
use rusqlite::hooks::{AuthAction, AuthContext, Authorization};
use rusqlite::{Connection, Result};

pub fn install(conn: &Connection) -> Result<()> {
    conn.create_scalar_function("clm_verified_algorithm", 3, FunctionFlags::SQLITE_UTF8, |ctx| {
        let content = match ctx.get_raw(1) {
            rusqlite::types::ValueRef::Text(bytes) | rusqlite::types::ValueRef::Blob(bytes) => bytes.to_vec(),
            _ => return Err(rusqlite::Error::UserFunctionError("card content must be text or bytes".into())),
        };
        let record = MCardRecord { hash: ctx.get(0)?, content, g_time: ctx.get(2)? };
        super::record_store::require_verified(&record)
            .map_err(|error| rusqlite::Error::UserFunctionError(error.to_string().into()))
    })?;
    conn.execute_batch("PRAGMA recursive_triggers = ON;
        DROP TRIGGER IF EXISTS temp.clm_card_insert;
        DROP TRIGGER IF EXISTS temp.clm_card_update;
        CREATE TEMP TRIGGER clm_card_insert BEFORE INSERT ON main.card BEGIN
            SELECT clm_verified_algorithm(NEW.hash, NEW.content, NEW.g_time);
            SELECT CASE WHEN EXISTS (SELECT 1 FROM main.card AS old WHERE old.hash = NEW.hash
                AND (CAST(old.content AS BLOB) != CAST(NEW.content AS BLOB)
                OR clm_verified_algorithm(old.hash, old.content, old.g_time)
                    != clm_verified_algorithm(NEW.hash, NEW.content, NEW.g_time)))
                THEN RAISE(ABORT, 'conflicting content-addressed row') END;
            SELECT RAISE(IGNORE) WHERE EXISTS (SELECT 1 FROM main.card WHERE hash = NEW.hash);
        END;
        CREATE TEMP TRIGGER clm_card_update BEFORE UPDATE ON main.card BEGIN
            SELECT clm_verified_algorithm(NEW.hash, NEW.content, NEW.g_time);
            SELECT clm_verified_algorithm(OLD.hash, OLD.content, OLD.g_time);
            SELECT CASE WHEN NEW.hash != OLD.hash OR CAST(NEW.content AS BLOB) != CAST(OLD.content AS BLOB)
                OR NEW.g_time != OLD.g_time THEN RAISE(ABORT, 'content-addressed rows are immutable') END;
        END;")?;
    for (name, action) in [("clm_head_insert", "INSERT"), ("clm_head_update", "UPDATE")] {
        conn.execute_batch(&format!("DROP TRIGGER IF EXISTS temp.{name};
            CREATE TEMP TRIGGER {name} BEFORE {action} ON main.handle_registry BEGIN
                SELECT clm_verified_algorithm(NEW.current_hash,
                    (SELECT content FROM main.card WHERE hash=NEW.current_hash OR hash=substr(NEW.current_hash,instr(NEW.current_hash,':')+1) ORDER BY hash=NEW.current_hash DESC LIMIT 1),
                    (SELECT g_time FROM main.card WHERE hash=NEW.current_hash OR hash=substr(NEW.current_hash,instr(NEW.current_hash,':')+1) ORDER BY hash=NEW.current_hash DESC LIMIT 1));
            END;"))?;
    }
    conn.authorizer(Some(|context: AuthContext<'_>| {
        let protected = |name: &str| ["card", "handle_registry"].iter().any(|table| name.eq_ignore_ascii_case(table));
        let deny = match context.action {
            AuthAction::Attach { .. } | AuthAction::Detach { .. } => true,
            AuthAction::AlterTable { table_name, .. }
            | AuthAction::DropTable { table_name }
            | AuthAction::DropTempTable { table_name }
            | AuthAction::CreateTempTable { table_name }
            | AuthAction::CreateVtable { table_name, .. }
            | AuthAction::DropVtable { table_name, .. }
            | AuthAction::CreateTrigger { table_name, .. }
            | AuthAction::CreateTempTrigger { table_name, .. }
            | AuthAction::DropTrigger { table_name, .. }
            | AuthAction::DropTempTrigger { table_name, .. } => protected(table_name),
            AuthAction::CreateTempView { view_name } | AuthAction::CreateView { view_name } => protected(view_name),
            AuthAction::Pragma { pragma_name, pragma_value } if pragma_name.eq_ignore_ascii_case("query_only") =>
                pragma_value.is_some_and(|value| !["1", "on", "true"].iter().any(|safe| value.eq_ignore_ascii_case(safe))),
            AuthAction::Pragma { pragma_name, pragma_value } => pragma_value.is_some()
                && ["writable_schema", "recursive_triggers", "trusted_schema", "temp_store", "temp_store_directory"].iter()
                    .any(|name| pragma_name.eq_ignore_ascii_case(name)),
            AuthAction::Function { function_name } => function_name.eq_ignore_ascii_case("load_extension"),
            AuthAction::Insert { table_name } | AuthAction::Update { table_name, .. }
            | AuthAction::Delete { table_name } => protected(table_name)
                && context.database_name != Some("main"),
            _ => false,
        };
        if deny { Authorization::Deny } else { Authorization::Allow }
    }));
    Ok(())
}