ligerito 0.6.2

Ligerito polynomial commitment scheme over binary extension fields
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

//! Phase 2 integration tests: Read-only memory support

use ligerito::pcvm::{
    memory::ReadOnlyMemory,
    trace::{execute_and_trace_with_memory, Instruction, Opcode, Program},
};

#[test]
fn test_simple_load() {
    // Create memory with a constant value
    let mut memory = ReadOnlyMemory::with_size(0x2000);
    memory.write(0x1000, 42).unwrap();

    // Program: Load value from memory
    let program = vec![
        Instruction::new_imm(1, 0x1000), // a1 = 0x1000 (address)
        Instruction::new_load(0, 1, 0),  // a0 = mem[a1 + 0] = mem[0x1000] = 42
        Instruction::halt(),
    ];

    let initial_regs = [0u32; 13];
    let trace = execute_and_trace_with_memory(&program, initial_regs, Some(&memory));

    assert!(trace.validate().is_ok());

    let final_state = trace.final_state().unwrap();
    assert_eq!(final_state[0], 42, "a0 should contain loaded value");
}

#[test]
fn test_load_with_offset() {
    // Create memory with values
    let mut memory = ReadOnlyMemory::with_size(0x2000);
    memory.write(0x1000, 10).unwrap();
    memory.write(0x1004, 20).unwrap();
    memory.write(0x1008, 30).unwrap();

    // Program: Load with offset
    let program = vec![
        Instruction::new_imm(1, 0x1000), // a1 = 0x1000 (base address)
        Instruction::new_load(0, 1, 0),  // a0 = mem[0x1000] = 10
        Instruction::new_load(2, 1, 4),  // a2 = mem[0x1004] = 20
        Instruction::new_load(3, 1, 8),  // a3 = mem[0x1008] = 30
        Instruction::halt(),
    ];

    let initial_regs = [0u32; 13];
    let trace = execute_and_trace_with_memory(&program, initial_regs, Some(&memory));

    assert!(trace.validate().is_ok());

    let final_state = trace.final_state().unwrap();
    assert_eq!(final_state[0], 10);
    assert_eq!(final_state[2], 20);
    assert_eq!(final_state[3], 30);
}

#[test]
fn test_load_and_compute() {
    // Load two values and compute with them
    let mut memory = ReadOnlyMemory::with_size(0x2000);
    memory.write(0x1000, 15).unwrap();
    memory.write(0x1004, 25).unwrap();

    // Program: Load and add
    let program = vec![
        Instruction::new_imm(1, 0x1000),            // a1 = 0x1000
        Instruction::new_load(0, 1, 0),             // a0 = mem[0x1000] = 15
        Instruction::new_load(2, 1, 4),             // a2 = mem[0x1004] = 25
        Instruction::new_rrr(Opcode::ADD, 3, 0, 2), // a3 = a0 + a2 = 40
        Instruction::halt(),
    ];

    let initial_regs = [0u32; 13];
    let trace = execute_and_trace_with_memory(&program, initial_regs, Some(&memory));

    assert!(trace.validate().is_ok());

    let final_state = trace.final_state().unwrap();
    assert_eq!(final_state[3], 40);
}

#[test]
fn test_memory_hash_integrity() {
    let mut mem1 = ReadOnlyMemory::with_size(100);
    mem1.write(50, 123).unwrap();

    let mut mem2 = ReadOnlyMemory::with_size(100);
    mem2.write(50, 456).unwrap();

    // Different memory contents should have different hashes
    assert_ne!(mem1.hash, mem2.hash);

    // Same contents should have same hash
    let mut mem3 = ReadOnlyMemory::with_size(100);
    mem3.write(50, 123).unwrap();
    assert_eq!(mem1.hash, mem3.hash);
}

#[test]
fn test_backward_compatibility() {
    // Phase 1 programs (no memory) should still work
    let program = vec![
        Instruction::new_imm(0, 10),
        Instruction::new_imm(1, 20),
        Instruction::new_rrr(Opcode::ADD, 2, 0, 1),
        Instruction::halt(),
    ];

    let initial_regs = [0u32; 13];

    // Should work without memory
    let trace = execute_and_trace_with_memory(&program, initial_regs, None);
    assert!(trace.validate().is_ok());

    let final_state = trace.final_state().unwrap();
    assert_eq!(final_state[2], 30);
}

#[test]
fn test_load_out_of_bounds() {
    // Load from invalid address returns 0
    let memory = ReadOnlyMemory::with_size(100);

    let program = vec![
        Instruction::new_imm(1, 1000),  // a1 = 1000 (out of bounds)
        Instruction::new_load(0, 1, 0), // a0 = mem[1000] = 0 (default)
        Instruction::halt(),
    ];

    let initial_regs = [0u32; 13];
    let trace = execute_and_trace_with_memory(&program, initial_regs, Some(&memory));

    assert!(trace.validate().is_ok());

    let final_state = trace.final_state().unwrap();
    assert_eq!(final_state[0], 0, "Out of bounds read should return 0");
}