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

Merge branch 'main' of github.com:mir-protocol/plonky2 into fp318

Browse Source
This commit is contained in:
Dmitry Vagner 2023-03-22 16:58:54 -07:00
commit 3f4d970f15
5 changed files with 110 additions and 23 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
evm/src/cpu/kernel/asm/core/create.asm
View File

@ -47,10 +47,10 @@ global sys_create2:
SWAP4
%stack (salt) -> (salt, sys_create2_got_address)
// stack: salt, sys_create2_got_address, value, code_offset, code_len, kexit_info
DUP4 // code_len
DUP4 // code_offset
DUP5 // code_len
DUP5 // code_offset
PUSH @SEGMENT_MAIN_MEMORY
PUSH 0 // context
GET_CONTEXT
KECCAK_GENERAL
// stack: hash, salt, sys_create2_got_address, value, code_offset, code_len, kexit_info
%address

25
evm/src/cpu/kernel/asm/core/create_addresses.asm
View File

@ -34,15 +34,28 @@ global get_create_address:
// Computes the address for a contract based on the CREATE2 rule, i.e.
// address = KEC(0xff || sender || salt || code_hash)[12:]
//
// Pre stack: sender, salt, code_hash, retdest
// Clobbers @SEGMENT_KERNEL_GENERAL.
// Pre stack: sender, code_hash, salt, retdest
// Post stack: address
global get_create2_address:
// stack: sender, salt, code_hash, retdest
// TODO: Replace with actual implementation.
%pop3
PUSH 123
// stack: sender, code_hash, salt, retdest
PUSH 0xff PUSH 0 %mstore_kernel_general
%stack (sender, code_hash, salt, retdest) -> (0, @SEGMENT_KERNEL_GENERAL, 1, sender, 20, get_create2_address_contd, salt, code_hash, retdest)
%jump(mstore_unpacking)
get_create2_address_contd:
POP
%stack (salt, code_hash, retdest) -> (0, @SEGMENT_KERNEL_GENERAL, 21, salt, 32, get_create2_address_contd2, code_hash, retdest)
%jump(mstore_unpacking)
get_create2_address_contd2:
POP
%stack (code_hash, retdest) -> (0, @SEGMENT_KERNEL_GENERAL, 53, code_hash, 32, get_create2_address_finish, retdest)
%jump(mstore_unpacking)
get_create2_address_finish:
POP
%stack (retdest) -> (0, @SEGMENT_KERNEL_GENERAL, 0, 85, retdest) // context, segment, offset, len
KECCAK_GENERAL
// stack: address, retdest
%mod_const(0x10000000000000000000000000000000000000000) // 2^160
%observe_new_address
SWAP1
JUMP

6
evm/src/cpu/kernel/asm/memory/metadata.asm
View File

@ -201,7 +201,7 @@ global sys_basefee:
// stack: old_num_words, num_words, kexit_info
DUP2 DUP2 GT
// stack: old_num_words > num_words, old_num_words, num_words, kexit_info
%jumpi(%%end)
%jumpi(%%no_update)
// stack: old_num_words, num_words, kexit_info
%memory_cost
// stack: old_cost, num_words, kexit_info
@ -214,6 +214,10 @@ global sys_basefee:
SUB
// stack: additional_cost, kexit_info
%charge_gas
%jump(%%end)
%%no_update:
// stack: old_num_words, num_words, kexit_info
%pop2
%%end:
// stack: kexit_info
%endmacro

6
evm/src/cpu/kernel/asm/memory/syscalls.asm
View File

@ -124,14 +124,14 @@ sys_calldataload_after_mload_packing:
// stack: kexit_info, dest_offset, offset, size
DUP4 %num_bytes_to_num_words %mul_const(@GAS_COPY) %add_const(@GAS_VERYLOW) %charge_gas
%stack (kexit_info, dest_offset, offset, size) -> (dest_offset, size, dest_offset, offset, size, kexit_info)
%stack (kexit_info, dest_offset, offset, size) -> (dest_offset, size, kexit_info, dest_offset, offset, size)
ADD // TODO: check for overflow, see discussion here https://github.com/mir-protocol/plonky2/pull/930/files/a4ea0965d79561c345e2f77836c07949c7e0bc69#r1143630253
// stack: expanded_num_bytes, dest_offset, offset, size, kexit_info
// stack: expanded_num_bytes, kexit_info, dest_offset, offset, size, kexit_info
DUP1 %ensure_reasonable_offset
%update_mem_bytes
GET_CONTEXT
%stack (context, dest_offset, offset, size, kexit_info) ->
%stack (context, kexit_info, dest_offset, offset, size) ->
(context, @SEGMENT_MAIN_MEMORY, dest_offset, context, $segment, offset, size, %%after, kexit_info)
%jump(memcpy)
%%after:

84
evm/src/cpu/kernel/tests/core/create_addresses.rs
View File

@ -1,6 +1,9 @@
use std::str::FromStr;
use anyhow::Result;
use ethereum_types::U256;
use ethereum_types::{H256, U256};
use hex_literal::hex;
use keccak_hash::keccak;
use crate::cpu::kernel::aggregator::KERNEL;
use crate::cpu::kernel::interpreter::Interpreter;
@ -24,22 +27,89 @@ fn test_get_create_address() -> Result<()> {
Ok(())
}
struct Create2TestCase {
code_hash: H256,
salt: U256,
sender: U256,
expected_addr: U256,
}
/// Taken from https://eips.ethereum.org/EIPS/eip-1014
fn create2_test_cases() -> Vec<Create2TestCase> {
vec![
Create2TestCase {
code_hash: keccak(hex!("00")),
salt: U256::zero(),
sender: U256::zero(),
expected_addr: U256::from_str("0x4D1A2e2bB4F88F0250f26Ffff098B0b30B26BF38").unwrap(),
},
Create2TestCase {
code_hash: keccak(hex!("00")),
salt: U256::zero(),
sender: U256::from_str("0xdeadbeef00000000000000000000000000000000").unwrap(),
expected_addr: U256::from_str("0xB928f69Bb1D91Cd65274e3c79d8986362984fDA3").unwrap(),
},
Create2TestCase {
code_hash: keccak(hex!("00")),
salt: U256::from_str(
"0x000000000000000000000000feed000000000000000000000000000000000000",
)
.unwrap(),
sender: U256::from_str("0xdeadbeef00000000000000000000000000000000").unwrap(),
expected_addr: U256::from_str("0xD04116cDd17beBE565EB2422F2497E06cC1C9833").unwrap(),
},
Create2TestCase {
code_hash: keccak(hex!("deadbeef")),
salt: U256::zero(),
sender: U256::zero(),
expected_addr: U256::from_str("0x70f2b2914A2a4b783FaEFb75f459A580616Fcb5e").unwrap(),
},
Create2TestCase {
code_hash: keccak(hex!("deadbeef")),
salt: U256::from_str(
"0x00000000000000000000000000000000000000000000000000000000cafebabe",
)
.unwrap(),
sender: U256::from_str("0x00000000000000000000000000000000deadbeef").unwrap(),
expected_addr: U256::from_str("0x60f3f640a8508fC6a86d45DF051962668E1e8AC7").unwrap(),
},
Create2TestCase {
code_hash: keccak(hex!("deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef")),
salt: U256::from_str(
"0x00000000000000000000000000000000000000000000000000000000cafebabe",
)
.unwrap(),
sender: U256::from_str("0x00000000000000000000000000000000deadbeef").unwrap(),
expected_addr: U256::from_str("0x1d8bfDC5D46DC4f61D6b6115972536eBE6A8854C").unwrap(),
},
Create2TestCase {
code_hash: keccak(hex!("")),
salt: U256::zero(),
sender: U256::zero(),
expected_addr: U256::from_str("0xE33C0C7F7df4809055C3ebA6c09CFe4BaF1BD9e0").unwrap(),
},
]
}
#[test]
fn test_get_create2_address() -> Result<()> {
let get_create2_address = KERNEL.global_labels["get_create2_address"];
// TODO: Replace with real data once we have a real implementation.
let retaddr = 0xdeadbeefu32.into();
let code_hash = 0.into();
let salt = 5.into();
let sender = 0.into();
let expected_addr = 123.into();
let initial_stack = vec![retaddr, code_hash, salt, sender];
for Create2TestCase {
code_hash,
salt,
sender,
expected_addr,
} in create2_test_cases()
{
let initial_stack = vec![retaddr, salt, U256::from(code_hash.0), sender];
let mut interpreter = Interpreter::new_with_kernel(get_create2_address, initial_stack);
interpreter.run()?;
assert_eq!(interpreter.stack(), &[expected_addr]);
}
Ok(())
}