basic validation passes

src/input_structs/stark_config.cairo

@@ -1,3 +1,5 @@
+use cairo_verifier::vector_commitment::vector_commitment::VectorCommitmentConfig;
+
 #[derive(Drop, Serde)]
 struct StarkConfig {
     traces: TracesConfig,
@@ -23,16 +25,10 @@ struct TracesConfig {
 
 #[derive(Drop, Serde)]
 struct TableCommitmentConfig {
-    columns: felt252,
+    n_columns: felt252,
     vector: VectorCommitmentConfig
 }
 
-#[derive(Drop, Serde)]
-struct VectorCommitmentConfig {
-    height: felt252,
-    verifier_friendly_commitment_layers: felt252,
-}
-
 #[derive(Drop, Serde)]
 struct FriConfig {
     // Log2 of the size of the input layer to FRI.

src/lib.cairo

@@ -1,17 +1,20 @@
+mod air;
 mod channel;
 mod common;
+mod fri;
 mod input_structs;
-mod structs;
-mod air;
 mod oods;
-mod fri;
+mod queries;
+mod structs;
 mod table_commitment;
+mod validation;
 mod vector_commitment;
-mod queries;
 
-use cairo_verifier::input_structs::stark_proof::StarkProof;
+use cairo_verifier::{input_structs::stark_proof::StarkProof, validation::stark::verify_stark_proof};
+
 
 fn main(x: Array<felt252>) {
     let mut x_span = x.span();
     let stark_proof: StarkProof = Serde::deserialize(ref x_span).unwrap();
+    verify_stark_proof(stark_proof);
 }

src/validation.cairo

@@ -0,0 +1,5 @@
+mod asserts;
+mod config;
+mod proof_of_work;
+mod stark_config;
+mod stark;

src/validation/asserts.cairo

@@ -0,0 +1,6 @@
+use cairo_verifier::common::math::Felt252PartialOrd;
+
+fn assert_in_range(x: felt252, min: felt252, max: felt252) {
+    assert(min <= x, 'Value too small');
+    assert(x < max, 'Value too large');
+}

src/validation/config.cairo

@@ -0,0 +1,31 @@
+use cairo_verifier::{
+    input_structs::stark_config::TracesConfig, validation::asserts::assert_in_range,
+    vector_commitment::vector_commitment::validate_vector_commitment,
+    fri::fri_config::fri_config_validate,
+};
+
+const MAX_N_COLUMNS: felt252 = 128;
+const AIR_LAYOUT_N_ORIGINAL_COLUMNS: felt252 = 12;
+const AIR_LAYOUT_N_INTERACTION_COLUMNS: felt252 = 3;
+
+// Validates the configuration of the traces.
+// log_eval_domain_size - Log2 of the evaluation domain size.
+fn traces_config_validate(
+    config: TracesConfig,
+    log_eval_domain_size: felt252,
+    n_verifier_friendly_commitment_layers: felt252,
+) {
+    assert_in_range(config.original.n_columns, 1, MAX_N_COLUMNS + 1);
+    assert_in_range(config.interaction.n_columns, 1, MAX_N_COLUMNS + 1);
+    assert(config.original.n_columns == AIR_LAYOUT_N_ORIGINAL_COLUMNS, 'Wrong number of columns');
+    assert(
+        config.interaction.n_columns == AIR_LAYOUT_N_INTERACTION_COLUMNS, 'Wrong number of columns'
+    );
+
+    // validate_vector_commitment(
+    //     config.original.vector, log_eval_domain_size, n_verifier_friendly_commitment_layers,
+    // );
+    // validate_vector_commitment(
+    //     config.interaction.vector, log_eval_domain_size, n_verifier_friendly_commitment_layers,
+    // );
+}

src/validation/proof_of_work.cairo

@@ -0,0 +1,10 @@
+use cairo_verifier::input_structs::stark_config::ProofOfWorkConfig;
+use cairo_verifier::common::math::Felt252PartialOrd;
+
+const MIN_PROOF_OF_WORK_BITS: felt252 = 30;
+const MAX_PROOF_OF_WORK_BITS: felt252 = 50;
+
+fn proof_of_work_config_validate(config: ProofOfWorkConfig) {
+    assert(MIN_PROOF_OF_WORK_BITS <= config.n_bits, 'Too few bits for proof of work');
+    assert(config.n_bits < MAX_PROOF_OF_WORK_BITS, 'Too many bits for proof of work');
+}

src/validation/stark.cairo

@@ -0,0 +1,11 @@
+use cairo_verifier::{
+    input_structs::stark_proof::StarkProof,
+    validation::stark_config::stark_config_validate
+};
+
+const SECURITY_BITS: felt252 = 96;
+
+
+fn verify_stark_proof(proof: StarkProof) {
+    stark_config_validate(proof.config, SECURITY_BITS);
+}

src/validation/stark_config.cairo

@@ -0,0 +1,24 @@
+use cairo_verifier::{
+    input_structs::stark_config::StarkConfig,
+    validation::{proof_of_work::proof_of_work_config_validate, config::traces_config_validate},
+    vector_commitment::vector_commitment::validate_vector_commitment,
+    fri::fri_config::fri_config_validate,
+};
+
+fn stark_config_validate(stark_config: StarkConfig, security_bits: felt252) {
+    proof_of_work_config_validate(stark_config.proof_of_work);
+
+    let log_eval_domain_size = stark_config.log_trace_domain_size + stark_config.log_n_cosets;
+    traces_config_validate(stark_config.traces, log_eval_domain_size, security_bits);
+
+    // validate_vector_commitment(
+    //     stark_config.composition.vector,
+    //     log_eval_domain_size,
+    //     stark_config.n_verifier_friendly_commitment_layers
+    // );
+    // fri_config_validate(
+    //     stark_config.fri,
+    //     stark_config.log_n_cosets,
+    //     stark_config.n_verifier_friendly_commitment_layers
+    // );
+}

src/vector_commitment/vector_commitment.cairo

@@ -12,7 +12,7 @@ struct VectorCommitment {
     commitment_hash: felt252
 }
 
-#[derive(Drop, Copy)]
+#[derive(Drop, Copy, Serde)]
 struct VectorCommitmentConfig {
     height: felt252,
     n_verifier_friendly_commitment_layers: felt252,