logos-storage/plonky2
1
0
Fork 0
mirror of https://github.com/logos-storage/plonky2.git synced 2026-01-08 16:53:07 +00:00
Code Issues Packages Projects Releases Wiki Activity

test is running, but failing

Browse Source
This commit is contained in:
Dmitry Vagner 2022-09-22 09:27:11 -07:00
parent 65b393cb95
commit 7ee583551c
2 changed files with 29 additions and 88 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
evm/src/cpu/kernel/asm/ripemd/ripemd.asm
View File

@ -80,9 +80,9 @@ process:
%shl_const(96) %shl_const(96)
OR OR
// stack: e' d' c' b' a', VARS // stack: e' d' c' b' a', VARS
%stack (result, VARS: 3, fin) -> (fin, result) %stack (result, VARS: 3) -> (0xdeadbeef, result)
// stack: 0xdeadbeef, result // stack: 0xdeadbeef, result
JUMP JUMP
/// def padlength(length): /// def padlength(length):

113
evm/src/cpu/kernel/tests/ripemd.rs
View File

@ -1,99 +1,40 @@
use anyhow::Result; use anyhow::Result;
use ethereum_types::U256; use ethereum_types::U256;
use rand::{thread_rng, Rng};
use crate::cpu::kernel::aggregator::combined_kernel; use crate::cpu::kernel::aggregator::combined_kernel;
use crate::cpu::kernel::interpreter::{run, run_with_kernel}; use crate::cpu::kernel::interpreter::run_with_kernel;
#[test] #[test]
fn test_ripemd() -> Result<()> { fn test_ripemd() -> Result<()> {
// Make sure we can parse and assemble the entire kernel. let expected = "0xf71c27109c692c1b56bbdceb5b9d2865b3708dbc";
println!("{}", expected);
let kernel = combined_kernel(); let kernel = combined_kernel();
let exp = kernel.global_labels["exp"];
let mut rng = thread_rng();
let a = U256([0; 4].map(|_| rng.gen()));
let b = U256([0; 4].map(|_| rng.gen()));
// Random input let input: Vec<u32> = vec![
let initial_stack = vec![0xDEADBEEFu32.into(), b, a]; 26, 0x61, 0x62,
let stack_with_kernel = run_with_kernel(&kernel, exp, initial_stack)? 0x63, 0x64, 0x65, 0x66,
.stack() 0x67, 0x68, 0x69, 0x6a,
.to_vec(); 0x6b, 0x6c, 0x6d, 0x6e,
let initial_stack = vec![b, a]; 0x6f, 0x70, 0x71, 0x72,
let code = [0xa, 0x63, 0xde, 0xad, 0xbe, 0xef, 0x56]; // EXP, PUSH4 deadbeef, JUMP 0x73, 0x74, 0x75, 0x76,
let stack_with_opcode = run(&code, 0, initial_stack, &kernel.prover_inputs)? 0x77, 0x78, 0x79, 0x7a,
.stack() ];
.to_vec(); let stack_init:Vec<U256> = input
assert_eq!(stack_with_kernel, stack_with_opcode); .iter()
.map(|&x| U256::from(x as u32))
.rev()
.collect();
// let expected = "0xf71c27109c692c1b56bbdceb5b9d2865b3708dbc"; let stack_result = run_with_kernel(
// println!("{}", expected); &kernel,
kernel.global_labels["ripemd_alt"],
// let kernel = combined_kernel(); stack_init,
)?;
// let input: Vec<u32> = vec![ let result = stack_result.stack()[0];
// 0x61, 0x62, let actual = format!("{:X}", result);
// 0x63, 0x64, 0x65, 0x66, println!("{}", actual);
// 0x67, 0x68, 0x69, 0x6a, assert_eq!(expected, actual);
// 0x6b, 0x6c, 0x6d, 0x6e,
// 0x6f, 0x70, 0x71, 0x72,
// 0x73, 0x74, 0x75, 0x76,
// 0x77, 0x78, 0x79, 0x7a,
// ];
// let mut stack_init:Vec<U256> = input.iter().map(|&x| U256::from(x as u32)).collect();
// stack_init.push(U256::from_str("0xdeadbeef").unwrap());
// let stack_result = run(
// &kernel.code,
// kernel.global_labels["ripemd_alt"],
// stack_init,
// &kernel.prover_inputs
// )?;
// let result = stack_result.stack()[1];
// let actual = format!("{:X}", result);
// println!("{}", actual);
// assert_eq!(expected, actual);
Ok(()) Ok(())
} }
// use std::str::FromStr;
// use anyhow::Result;
// use ethereum_types::U256;
// use rand::{thread_rng, Rng};
// use sha2::{Digest, Sha256};
// use crate::cpu::kernel::aggregator::combined_kernel;
// use crate::cpu::kernel::interpreter::run;
// #[test]
// fn test_sha2() -> Result<()> {
// let kernel = combined_kernel();
// let sha2 = kernel.global_labels["sha2"];
// let mut rng = thread_rng();
// let num_bytes = rng.gen_range(0..10000);
// let message: Vec<u8> = (0..num_bytes).map(|_| rng.gen()).collect();
// let mut hasher = Sha256::new();
// hasher.update(message.clone());
// let expected = format!("{:X}", hasher.finalize());
// let bytes: Vec<U256> = message.iter().map(|&x| U256::from(x as u32)).collect();
// let mut initial_stack = vec![U256::from(num_bytes)];
// initial_stack.extend(bytes);
// initial_stack.push(U256::from_str("0xdeadbeef").unwrap());
// initial_stack.reverse();
// let after_sha2 = run(&kernel.code, sha2, initial_stack, &kernel.prover_inputs)?;
// let stack_after_sha2 = after_sha2.stack();
// let result = stack_after_sha2[1];
// let actual = format!("{:X}", result);
// assert_eq!(expected, actual);
// Ok(())
// }