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

Implement CREATE2 address generation (#936)

Browse Source 
* Implement create2 address gen

* Clippy

* Minor

* Wrong order

* Fix test

* Fix comment
This commit is contained in:
wborgeaud 2023-03-22 19:14:17 +01:00 committed by GitHub
parent d0b2b81e11
commit 15bafce5dd
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 102 additions and 19 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

90
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];
let mut interpreter = Interpreter::new_with_kernel(get_create2_address, initial_stack);
interpreter.run()?;
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]);
assert_eq!(interpreter.stack(), &[expected_addr]);
}
Ok(())
}