Implement Data Processor module in cairo

Author: fmkra

cairo/src/data_processor.cairo

@@ -0,0 +1,237 @@
+use core::keccak::keccak_u256s_be_inputs;
+use cairo_lib::utils::bitwise::reverse_endianness_u256;
+
+#[derive(Drop, Serde, starknet::Store, PartialEq)]
+enum TaskStatus {
+    NONE,
+    SCHEDULED,
+    FINALIZED
+}
+
+#[derive(Drop, Serde, starknet::Store)]
+struct TaskResult {
+    status: TaskStatus,
+    result: u256,
+}
+
+#[derive(Drop, Serde)]
+struct MmrData {
+    chain_id: u256,
+    mmr_id: u256,
+    mmr_size: u256,
+}
+
+#[derive(Drop, Serde)]
+struct TaskData {
+    mmr_data: Span<MmrData>,
+    task_result_low: u128,
+    task_result_high: u128,
+    task_hash_low: u128,
+    task_hash_high: u128,
+    module_hash: u256,
+    program_hash: felt252,
+}
+
+#[derive(Drop, Serde)]
+struct ModuleTask {
+    program_hash: u256,
+    inputs: Span<u256>,
+}
+
+#[starknet::interface]
+pub trait IDataProcessor<TContractState> {
+    // ========================= Setup Functions ========================= //
+
+    /// Set the program hash for the HDP program
+    fn setDataProcessorProgramHash(ref self: TContractState, program_hash: felt252);
+
+    /// Disable some program hashes
+    fn disableProgramHashes(ref self: TContractState, program_hashes: Span<felt252>);
+
+    /// Checks if a program hash is currently authorized
+    fn isProgramHashAuthorized(self: @TContractState, program_hash: felt252) -> bool;
+
+    // ========================= Core Functions ========================= //
+
+    /// Requests the execution of a task with a module
+    fn requestDataProcessorExecutionOfTask(ref self: TContractState, module_task: ModuleTask);
+    
+    /// Authenticates the execution of a task is finalized by verifying the locally computed fact with the FactsRegistry
+    fn authenticateDataProcessorTaskExecution(ref self: TContractState, task_data: TaskData);
+
+    /// Returns the status of a task
+    fn getDataProcessorTaskStatus(self: @TContractState, task_commitment: u256) -> TaskStatus;
+
+    /// Returns the result of a finalized task
+    fn getDataProcessorFinalizedTaskResult(self: @TContractState, task_commitment: u256) -> u256;
+}
+
+#[starknet::component]
+pub mod data_processor_component {
+    use crate::{
+        state::state_component,
+        mmr_core::mmr_core_component::MmrCoreExternalImpl,
+        mmr_core::POSEIDON_HASHING_FUNCTION,
+        cairo_fact_registry::{cairo_fact_registry_component, ICairoFactRegistry},
+    };
+    use starknet::storage::{
+        StoragePointerReadAccess, StoragePointerWriteAccess, StoragePathEntry, Map,
+    };
+    use openzeppelin::access::ownable::{
+        OwnableComponent, OwnableComponent::InternalTrait as OwnableInternal,
+    };
+    use integrity::calculate_fact_hash;
+    use super::*;
+
+    #[storage]
+    struct Storage {
+        cachedTasksResult: Map<u256, TaskResult>,
+        authorizedProgramHashes: Map<felt252, bool>,
+    }
+
+    #[derive(Drop, starknet::Event)]
+    struct ProgramHashEnabled {
+        program_hash: felt252,
+    }
+
+    #[derive(Drop, starknet::Event)]
+    struct ProgramHashesDisabled {
+        program_hashes: Span<felt252>,
+    }
+
+    #[derive(Drop, starknet::Event)]
+    struct TaskAlreadyStored {
+        task_commitment: u256,
+    }
+
+    #[derive(Drop, starknet::Event)]
+    struct ModuleTaskScheduled {
+        module_task: ModuleTask,
+    }
+
+    #[derive(Drop, starknet::Event)]
+    struct TaskFinalized {
+        task_hash: u256,
+        task_result: u256,
+    }
+
+    #[event]
+    #[derive(Drop, starknet::Event)]
+    pub enum Event {
+        ProgramHashEnabled: ProgramHashEnabled,
+        ProgramHashesDisabled: ProgramHashesDisabled,
+        TaskAlreadyStored: TaskAlreadyStored,
+        ModuleTaskScheduled: ModuleTaskScheduled,
+        TaskFinalized: TaskFinalized,
+    }
+
+    #[embeddable_as(DataProcessor)]
+    impl DataProcessorImpl<
+        TContractState,
+        +HasComponent<TContractState>,
+        +Drop<TContractState>,
+        impl State: state_component::HasComponent<TContractState>,
+        impl Ownable: OwnableComponent::HasComponent<TContractState>,
+        impl CairoFactRegistry: cairo_fact_registry_component::HasComponent<TContractState>,
+    > of IDataProcessor<ComponentState<TContractState>> {
+        // ========================= Setup Functions ========================= //
+
+        fn setDataProcessorProgramHash(ref self: ComponentState<TContractState>, program_hash: felt252) {
+            get_dep_component!(@self, Ownable).assert_only_owner();
+
+            self.authorizedProgramHashes.entry(program_hash).write(true);
+            self.emit(Event::ProgramHashEnabled(ProgramHashEnabled {program_hash}))
+        }
+
+        fn disableProgramHashes(ref self: ComponentState<TContractState>, program_hashes: Span<felt252>) {
+            get_dep_component!(@self, Ownable).assert_only_owner();
+
+            for program_hash in program_hashes {
+                self.authorizedProgramHashes.entry(*program_hash).write(false);
+            };
+            self.emit(Event::ProgramHashesDisabled(ProgramHashesDisabled{program_hashes}));
+        }
+
+        fn isProgramHashAuthorized(self: @ComponentState<TContractState>, program_hash: felt252) -> bool {
+            self.authorizedProgramHashes.entry(program_hash).read()
+        }
+
+        // ========================= Core Functions ========================= //
+
+        fn requestDataProcessorExecutionOfTask(ref self: ComponentState<TContractState>, module_task: ModuleTask) {
+            let mut keccak_input = array![module_task.program_hash];
+            for input in module_task.inputs {
+                keccak_input.append(*input);
+            };
+            let task_commitment = reverse_endianness_u256(keccak_u256s_be_inputs(keccak_input.span()));
+            
+            let cached_result = self.cachedTasksResult.entry(task_commitment);
+            let cached_result_status = cached_result.status.read();
+            if cached_result_status == TaskStatus::FINALIZED {
+                self.emit(Event::TaskAlreadyStored(TaskAlreadyStored {task_commitment} ));
+            } else {
+                // Ensure task is not already scheduled
+                assert(cached_result_status == TaskStatus::NONE, 'DOUBLE_REGISTRATION');
+    
+                // Store the task result
+                cached_result.write(TaskResult{status: TaskStatus::SCHEDULED, result: 0});
+    
+                self.emit(Event::ModuleTaskScheduled(ModuleTaskScheduled {module_task} ));
+            }
+        }
+
+        fn authenticateDataProcessorTaskExecution(ref self: ComponentState<TContractState>, task_data: TaskData) {
+            let task_hash = u256 {low: task_data.task_hash_low, high: task_data.task_hash_high };
+
+            assert(self.cachedTasksResult.entry(task_hash).status.read() != TaskStatus::FINALIZED, 'TaskAlreadyFinalized');
+
+            assert(self.isProgramHashAuthorized(task_data.program_hash), 'UnauthorizedProgramHash');
+
+            // Initialize an array of uint256 to store the program output
+            let mut program_output: Array<felt252> = array![];
+
+            // Assign values to the program output array
+            // This needs to be compatible with cairo program
+            // https://github.com/HerodotusDev/hdp-cairo/blob/main/src/utils/utils.cairo#L27-L48
+            program_output.append(task_data.task_hash_low.into());
+            program_output.append(task_data.task_hash_high.into());
+            program_output.append(task_data.task_result_low.into());
+            program_output.append(task_data.task_result_high.into());
+
+            let state = get_dep_component!(@self, State);
+            for mmr in task_data.mmr_data {
+                let mmr_root = state.mmrs.entry(*mmr.chain_id).entry(*mmr.mmr_id).entry(POSEIDON_HASHING_FUNCTION).mmr_size_to_root.entry(*mmr.mmr_size).read();
+                assert(mmr_root != 0, 'InvalidMmrRoot');
+                program_output.append((*mmr.mmr_id).try_into().expect('mmr_id not felt252'));
+                program_output.append((*mmr.mmr_size).try_into().expect('mmr_size not felt252'));
+                program_output.append((*mmr.chain_id).try_into().expect('chain_id not felt252'));
+                program_output.append(mmr_root.try_into().expect('mmr_root not felt252'));
+            };
+
+            let fact_hash = calculate_fact_hash(task_data.program_hash, program_output.span());
+
+            let cairo_fact_registry = get_dep_component!(@self, CairoFactRegistry);
+            assert(cairo_fact_registry.isCairoFactValidForInternal(fact_hash), 'Invalid fact');
+
+            let task_result = u256 {low: task_data.task_result_low, high: task_data.task_result_high};
+
+            // Store the task result
+            self.cachedTasksResult.entry(task_hash).write(TaskResult {status: TaskStatus::FINALIZED, result: task_result});
+            self.emit(Event::TaskFinalized(TaskFinalized {task_hash, task_result}));
+        }
+
+        fn getDataProcessorTaskStatus(self: @ComponentState<TContractState>, task_commitment: u256) -> TaskStatus {
+            self.cachedTasksResult.entry(task_commitment).status.read()
+        }
+
+        fn getDataProcessorFinalizedTaskResult(self: @ComponentState<TContractState>, task_commitment: u256) -> u256 {
+            let task_result = self.cachedTasksResult.entry(task_commitment).read();
+
+            // Ensure task is finalized
+            assert(task_result.status == TaskStatus::FINALIZED, 'TASK_NOT_FINALIZED');
+
+            task_result.result
+        }
+    }
+}
+

cairo/src/lib.cairo

@@ -5,6 +5,7 @@ pub mod receiver;
 pub mod evm_growing;
 pub mod utils;
 pub mod cairo_fact_registry;
+pub mod data_processor;
 // Main contract is in receiver.cairo file
 // because L1 handlers cannot be defined in components
 

cairo/src/receiver.cairo

@@ -13,6 +13,7 @@ pub mod StorageProofs {
         evm_fact_registry::evm_fact_registry_component,
         mmr_core::{mmr_core_component, RootForHashingFunction}, state::state_component,
         evm_growing::evm_growing_component, cairo_fact_registry::cairo_fact_registry_component,
+        data_processor::data_processor_component,
     };
     use starknet::{ClassHash, ContractAddress};
     use super::*;
@@ -28,6 +29,11 @@ pub mod StorageProofs {
         storage: cairo_fact_registry,
         event: CairoFactRegistryEvent,
     );
+    component!(
+        path: data_processor_component,
+        storage: data_processor,
+        event: DataProcessorEvent,
+    );
 
     // Ownable / Upgradeable
     component!(path: OwnableComponent, storage: ownable, event: OwnableEvent);
@@ -50,6 +56,8 @@ pub mod StorageProofs {
         evm_growing: evm_growing_component::Storage,
         #[substorage(v0)]
         cairo_fact_registry: cairo_fact_registry_component::Storage,
+        #[substorage(v0)]
+        data_processor: data_processor_component::Storage,
     }
 
     #[constructor]
@@ -121,6 +129,8 @@ pub mod StorageProofs {
         EvmGrowingEvent: evm_growing_component::Event,
         #[flat]
         CairoFactRegistryEvent: cairo_fact_registry_component::Event,
+        #[flat]
+        DataProcessorEvent: data_processor_component::Event,
     }
 
     #[abi(embed_v0)]
@@ -136,6 +146,12 @@ pub mod StorageProofs {
     #[abi(embed_v0)]
     impl EvmGrowingImpl = evm_growing_component::EvmGrowing<ContractState>;
 
+    #[abi(embed_v0)]
+    impl CairoFactRegistryImpl = cairo_fact_registry_component::CairoFactRegistry<ContractState>;
+
+    #[abi(embed_v0)]
+    impl DataProcessorImpl = data_processor_component::DataProcessor<ContractState>;
+
     // Ownable / Upgradeable
     #[abi(embed_v0)]
     impl OwnableMixinImpl = OwnableComponent::OwnableCamelOnlyImpl<ContractState>;