Create a common structure for verifiable state transition function

.gitignore

@@ -12,3 +12,9 @@ Cargo.lock
 
 # MSVC Windows builds of rustc generate these, which store debugging information
 *.pdb
+
+
+# Added by cargo
+
+/target
+/Cargo.lock

Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "vstf"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]

src/execution/isa/mod.rs

@@ -0,0 +1,53 @@
+use crate::state::cpu::CpuState;
+use crate::state_transition::Executable;
+
+#[derive(Debug, Clone)]
+pub enum Instruction {
+    Nop,
+    BinOp { op: BinaryOperation },
+    Branch(Branch),
+    Jump(usize),
+    Load,
+    Save,
+}
+
+impl Executable for Instruction {
+    type State = CpuState;
+    fn execute(&self, state: Self::State) -> Self::State {
+        match self {
+            Self::Nop => state,
+            _ => todo!(),
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum BinaryOperation {
+    Add,
+    Minus,
+    Multiply,
+    Divide,
+    Equal,
+    NotEqual,
+    LessThan,
+    GreaterThan,
+    And,
+    Or,
+    Xor,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Branch {
+    Beq,
+    Bne,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Operand {
+    Register(Register),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Register {
+    Temp(usize),
+}

src/execution/mod.rs

@@ -0,0 +1 @@
+pub mod isa;

src/lib.rs

@@ -0,0 +1,10 @@
+pub mod execution;
+pub mod state;
+pub mod state_transition;
+
+pub mod benches;
+
+#[derive(Debug, Clone)]
+pub enum Error {
+    Misc,
+}

src/state/cpu.rs

@@ -0,0 +1,14 @@
+use crate::state_transition::State;
+
+#[derive(Clone, Debug, Copy)]
+pub struct CpuState {
+    pub pc: usize,
+}
+
+impl CpuState {
+    pub fn init() -> Self {
+        CpuState { pc: 0 }
+    }
+}
+
+impl State for CpuState {}

src/state/mod.rs

@@ -0,0 +1 @@
+pub mod cpu;

src/state_transition/mod.rs

@@ -0,0 +1,34 @@
+use std::fmt::Debug;
+
+pub trait State: Clone + Debug {}
+
+pub trait Executable: Clone + Debug {
+    type State: State;
+    fn execute(&self, state: Self::State) -> Self::State;
+}
+
+pub trait Instance: Clone + Debug {
+    type ProvableObject: Clone + Debug;
+    type ProvedObject: Clone + Debug;
+    type Error: Clone + Debug;
+    type State: Clone + Debug;
+
+    fn prove(&self) -> Result<Self::ProvedObject, Self::Error>;
+    fn verify(&self) -> bool;
+}
+
+pub trait StateTransition: Clone + Debug {
+    type Provable: Instance;
+    type Executable: Clone + Debug;
+
+    type Error: Clone + Debug;
+
+    // if it uses folding or recursive method,
+    // then the number of element of each parameter should be 1
+    // And run this vstf for all steps
+    fn vstf(
+        input_instance: Vec<Self::Provable>,
+        result_instance: Self::Provable,
+        execution: Vec<Self::Executable>,
+    ) -> bool;
+}