geruiwangEXTCODECOPY
概述
CODECOPY
概述：该操作通常用于在智能合约中实现一些动态代码加载或代码复制的逻辑，将合约中字节码复制到Memory中，即将合约代码复制到内存的操作。
具体操作：从栈顶弹出三个值，分别为：destOffset、offset、length，根据当前三个值进行操作：memory[destOffset:destOffset+length] = address(this).code[offset:offset+length]，即从code中以offset的位置开始，复制长度为length的字节码到Memory以destOffset为起始的位置（都是以字节为单位进行操作）
trace示例：CODECOPY指令执行时，会从栈顶弹出三个值：destOffset、offset、length，然后根据这三个值进行合约代码的复制
PUSH1 0xa
PUSH30 0x02030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f
ADD
PUSH1 0x1E
PUSH1 0x03
PUSH1 0x00
CODECOPY
STOP此操作会从合约代码第3个字节开始复制，长度为30，复制到Memory以00起始的位置，即将02030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f 复制到Memory中
EXTCODECOPY
概述: 该操作类似CODECOPY,区别之处在于,可以通过参数指定合约源码地址栈顶。从栈顶第一个弹出的address来指定合约的源码地址,首先找到code=find_code_by(address),余下操作同CODECOPY
Witness Core Row
core row的表格设计如下：
cnt=2, vers[0]~vers[8] 为正常copy row进行LookUp的值
cnt=2, vers[8]~vers[17] 为padding copy row进行LookUp的值
/// +---+-------+-------+-------+----------+
/// |cnt| 8 col | 8 col | 8 col | 8 col |
/// +---+-------+-------+-------+----------+
/// | 2 | COPY(9) | ZEROCOPY(9)|
/// | 1 | STATE | STATE | STATE | STATE |
/// | 0 | DYNA_SELECTOR | AUX |
/// +---+-------+-------+-------+----------+解释
在进行copy时，offset即是要复制的合约的代码的起始位置start，复制长度为length，复制的结束位置end: start+length，但是在进行copy的时候可能存在边界问题，如下：
1）offset<=len(code), copy_len > 0, offset+copy_len <= len(code), 无需进行0填充
2）offset<=len(code), copy_len == 0, offset+copy_len <= len(code), 无需0填充， 也无需拷贝，即code[start:start]，为空
3）offset<=len(code), copy_len>0, offset_copy_len > len(code)，需要进行0填充，填充长度为 copy_len - (len(code)-offset) --> offset+copy_len - len(code)
4）offset>len(code), copy_len>=0, offset+copy_len > len(code)， 需要进行0填充，填充长度为offset+copy_len-len(code)
此外当 offset > u64时，会对offset进行特殊处理为u64的最大值
对于Padding的值也会被放到Memory中，Padding的值，Src部分都是默认值，dst部分正常填充（对Copy子电路来说，Padding部分，因为ByteCode中并不存在Padding的值，所以不存在来源，但是Padding的值也会被放入到Memory中，所以存在去向，所以Padding部分的LookUp无来源，但是有去向为State）。
不过padding中的dst部分在进行赋值时需要注意：dst_pointer和dst_stamp，因为在Copy子电路中，memory_addr=dst_pointer+cnt，memory_stamp=dst_stamp+cnt，而Padding和正常的Copy是分成两部分的(Padding在Copy子电路中的Type为Zero)，即Padding在Copy子电路中的cnt也是从0开始计数的。
举例如下：
合约代码长度：len(code)=5 进行CodeCopy操作： offset: 0 copy_len: 8 destOffset: 0 进行CodeCopy, 因为offset+copy_len > len(code) 所以需要填充0，填充长度为offset+copy_len - len(code) = 3, 所以整体CopyRow的生成就分成了两部分：正常的CopyRow5行，PaddingCopyRow3行。 加入在生成Copy时的stamp为1记为OriginalStamp 则NoPaddingCopyRow的Stamp都为1(OriginalStamp)，dest_pointer为destOffset+{0..4}, cnt为0～4 则PaddingCopyRow的Stamp为6(OriginalStamp+len(code))， dest_pointer为destOffset+len(code)+{0..2}, cnt为0~2 因为是分为两部分的，所以stamp、dest_pointer不是相同的
代码如下：
pub fn get_code_copy_rows_new(
&mut self,
address: U256,
dst: U256,
src: U256,
len: U256,
) -> (Vec<copy::Row>, Vec<state::Row>, u64, u64, u64) {
//...
// NoPaddingCopyRow赋值
let codecopy_stamp = self.state_stamp;
if code_copy_length > 0 {
for i in 0..code_copy_length {
let code = self.bytecode.get(&address).unwrap();
let byte = code.get((src_offset + i) as usize).unwrap().value;
copy_rows.push(copy::Row {
byte: byte.into(),
src_type: copy::Type::Bytecode,
src_id: address,
src_pointer: src_offset.into(),
src_stamp: None,
dst_type: copy::Type::Memory,
dst_id: self.call_id.into(),
dst_pointer: dst_offset.into(),
dst_stamp: codecopy_stamp.into(),
cnt: i.into(),
len: code_copy_length.into(),
});
state_rows.push(self.get_memory_write_row((dst_offset + i) as usize, byte));
}
}
// PaddingCopyRow赋值
let codecopy_padding_stamp = self.state_stamp;
if padding_length > 0 {
for i in 0..padding_length {
state_rows.push(
self.get_memory_write_row(
(dst_offset + code_copy_length + i) as usize,
0 as u8,
),
);
copy_rows.push(copy::Row {
byte: 0.into(),
src_type: copy::Type::default(),
src_id: 0.into(),
src_pointer: 0.into(),
src_stamp: None,
dst_type: copy::Type::Memory,
dst_id: self.call_id.into(),
dst_pointer: (dst_offset + code_copy_length).into(),
dst_stamp: codecopy_padding_stamp.into(),
cnt: i.into(),
len: U256::from(padding_length),
})
}
}
// ...
}此外还需要注意copy_len为0的特殊值，当copy_len为0时，NoPaddingCopyRow行数等于0， PaddingCopyRow行数等于0，则CoreRow cnt=2的值会存放两个全是默认值的CopyRow(即全为0的值)放在vers[0]~vers[17]，当NoPaddingCopyRow行数大于0，PaddingCopyRow行数等于0时，vers[8]~vers[17]会存放全是默认值当CopyRow(即全为0的值)
并且行数为0的情况并不会放到State和Copy子电路的表中，因为copy_len为0，理应该不做任何操作，代码示例如下:
fn gen_witness(&self, trace: &GethExecStep, current_state: &mut WitnessExecHelper) -> Witness {
let (stack_pop_0, address) = current_state.get_pop_stack_row_value(&trace);
assert!(address.leading_zeros() >= ADDRESS_ZERO_COUNT);
//let address_code = current_state.bytecode.get(&address).unwrap();
// ...
let (copy_rows, mem_rows, input_length, padding_length, code_copy_length) =
current_state.get_code_copy_rows_new(address, mem_offset, code_offset, size);
let mut default_copy_row = ¤t_state.get_none_copy_row();
if input_length > 0 && code_copy_length > 0 {
default_copy_row = ©_rows[0];
}
let mut default_padding_row = ¤t_state.get_none_padding_copy_row();
if input_length > 0 && padding_length > 0 {
default_padding_row = ©_rows[code_copy_length as usize]
}
// ...
if input_length > 0 {
Witness {
copy: copy_rows,
core: vec![core_row_2, core_row_1, core_row_0],
state: state_vec,
..Default::default()
}
} else {
Witness {
core: vec![core_row_2, core_row_1, core_row_0],
state: state_vec,
..Default::default()
}
}
}门约束
- 当前的OPCODE一致
- Stack Value约束(tag,state_stamp,call_id,stack_pointer,is_write)
- Auxiliary字段约束(state_stamp,stack_pointer,log_stamp,read_only),值得注意的是state_stamp的约束需要考虑copy的长度为0的情况
- next_pc=stack_top_value_lo (从栈顶获取的值作为要跳转的值，pc范围是在u64内的，只取value_lo即可)
- lookup_value约束: copy_lookup_len *(copy_lookup_src_type - Bytecode) ,当代码拷贝真实发生时候,src_type必然为Bytecode
- lookup_value约束: copy_lookup_len *(copy_lookup_dst_type - Memory), 当代码拷贝真实发生时候,dst_type必然为Memory
- lookup_value约束: copy_lookup_len *(copy_lookup_dst_id - call_id) ,当代码拷贝真实发生时候,dst_id必然为call_id
- lookup_value约束: copy_lookup_len *(copy_lookup_dst_stamp - copy_code_stamp_start -1) ,当代码拷贝真实发生时候,拷贝代码行开始处必然在最后一个出栈元素的下一行
- lookup_value约束: copy_lookup_len *(copy_lookup_src_id - address ),当代码拷贝真实发生时候,src_id必然为代码块的代码address
- lookup_value约束: copy_lookup_len *(copy_lookup_dst_pointer - mem_offset ), 当代码拷贝真实发生的时候,dst_pointer必然为内存偏移量
- lookup_value约束: copy_lookup_len *(copy_lookup_src_pointer - code_offset), 当代码拷贝真实发生的时候,src_pointer必然为代码偏移量
- lookup_value约束: copy_lookup_len + copy_padding_lookup_len - length, 代码拷贝长度 + padding的长度必然等于参数指定的拷贝长度
- lookup_value约束: copy_padding_lookup_src_type - Zero ,padding的src_type 为 Zero类型(也即default()类型)
- lookup_value约束: copy_padding_lookup_len* (copy_padding_lookup_dst_type - Memory) ,当真实有padding数据时候,dst_type应该为Memory
- lookup_value约束: copy_padding_lookup_src_id - 0 , padding的src_id为默认值0
- lookup_value约束: copy_padding_lookup_src_pointer - 0 , padding的src_pointer为默认值0
- lookup_value约束: copy_padding_lookup_len* (copy_padding_lookup_dst_pointer - copy_lookup_dst_pointer - copy_lookup_len ), 当真实有padding数据的时候, padding的dst_pointer 与 copy的dst_pointer相差拷贝的代码长度(copy_lookup_len)
- lookup_value约束: copy_padding_lookup_len* (copy_padding_lookup_dst_stamp - copy_code_stamp_start - copy_lookup_len - 1), 当真实有padding数据的时候,padding的dst_stamp与栈中最后一个元素所处的stamp相差真实拷贝的代码长度+1
可参考如下示例代码:
fn get_constraints(
&self,
config: &ExecutionConfig<F, NUM_STATE_HI_COL, NUM_STATE_LO_COL>,
meta: &mut VirtualCells<F>,
) -> Vec<(String, Expression<F>)> {
let opcode = meta.query_advice(config.opcode, Rotation::cur());
let pc_cur = meta.query_advice(config.pc, Rotation::cur());
let call_id = meta.query_advice(config.call_id, Rotation::cur());
let pc_next = meta.query_advice(config.pc, Rotation::next());
let (
copy_lookup_src_type,
copy_lookup_src_id,
copy_lookup_src_pointer,
_,
copy_lookup_dst_type,
copy_lookup_dst_id,
copy_lookup_dst_pointer,
copy_lookup_dst_stamp,
copy_lookup_len,
) = extract_lookup_expression!(copy, config.get_copy_lookup(meta));
let (
copy_padding_lookup_src_type,
copy_padding_lookup_src_id,
copy_padding_lookup_src_pointer,
_,
copy_padding_lookup_dst_type,
copy_padding_lookup_dst_id,
copy_padding_lookup_dst_pointer,
copy_padding_lookup_dst_stamp,
copy_padding_lookup_len,
) = extract_lookup_expression!(copy, config.get_copy_padding_lookup(meta));
let delta = AuxiliaryDelta {
state_stamp: STATE_STAMP_DELTA.expr()
+ copy_lookup_len.clone()
+ copy_padding_lookup_len.clone(),
stack_pointer: STACK_POINTER_DELTA.expr(),
..Default::default()
};
// auxiliary constraints ...
// stack constraints ...
// copy lookup constraints
constraints.extend([
(
"etxcodecopy src_type".into(),
copy_lookup_len.clone()
* (copy_lookup_src_type.clone() - (copy::Type::Bytecode as u8).expr()),
),
(
"extcodecopy dst_type".into(),
copy_lookup_len.clone()
* (copy_lookup_dst_type.clone() - (copy::Type::Memory as u8).expr()),
),
(
"extcodecopy dst_id".into(),
copy_lookup_len.clone() * (copy_lookup_dst_id.clone() - call_id.clone()),
),
(
"extcodecopy dst_stamp".into(),
copy_lookup_len.clone()
* (copy_lookup_dst_stamp.clone() - copy_code_stamp_start.clone() - 1.expr()),
),
(
"extcodecopy src_id".into(),
copy_lookup_len.clone()
* (copy_lookup_src_id
- copy_operands[0][0].clone() * pow_of_two::<F>(128)
- copy_operands[0][1].clone()),
),
(
"extcodecopy dst_pointer value_hi = 0".into(),
copy_operands[1][0].clone() - 0.expr(),
),
(
"extcodecopy dst_pointer".into(),
copy_lookup_len.clone()
* (copy_lookup_dst_pointer.clone() - copy_operands[1][1].clone()),
),
(
"extcodecopy src_pointer value_hi = 0".into(),
copy_operands[2][0].clone() - 0.expr(),
),
(
"extcodecopy src_pointer".into(),
copy_lookup_len.clone()
* (copy_lookup_src_pointer.clone() - copy_operands[2][1].clone()),
),
(
"extcodecopy len value_hi = 0".into(),
copy_operands[3][0].clone() - 0.expr(),
),
(
"extcodecopy len".into(),
copy_lookup_len.clone() + copy_padding_lookup_len.clone()
- copy_operands[3][1].clone(),
),
(
"extcodecopy padding src_type".into(),
copy_padding_lookup_src_type.clone() - (copy::Type::default() as u8).expr(),
),
(
"extcodecopy padding dst_type".into(),
copy_padding_lookup_len.clone()
* (copy_padding_lookup_dst_type.clone() - (copy::Type::Memory as u8).expr()),
),
(
"extcodecopy padding src_id".into(),
copy_padding_lookup_src_id.clone() - 0.expr(),
),
(
"extcodecopy padding src_pointer".into(),
copy_padding_lookup_src_pointer.clone() - 0.expr(),
),
(
"extcodecopy padding dst_id".into(),
copy_padding_lookup_len.clone()
* (copy_padding_lookup_dst_id.clone() - call_id.clone()),
),
(
"extcodecopy padding dst_pointer".into(),
copy_padding_lookup_len.clone()
* (copy_padding_lookup_dst_pointer.clone()
- copy_lookup_dst_pointer.clone()
- copy_lookup_len.clone()),
),
(
"extcodecopy padding copy_padding_lookup_dst_stamp".into(),
copy_padding_lookup_len.clone()
* (copy_padding_lookup_dst_stamp.clone()
- copy_code_stamp_start.clone()
- copy_lookup_len.clone()
- 1.expr()),
),
]);
// pc & opcode constrains ...
constraints
}LookUp约束
LookUp约束被放在cnt=2的CopyRow，被分为两个种约束：NoPaddingCopy的约束和PaddingCopy约束，各占9列: vers[0]~vers[8], vers[9]~vers[17]
参考Witness Code Row中的解释部分，当offset+copy_len > len(code)时，需要填充0，填充长度为offset+copy_len-len(code)。
来源：Core
去向：Copy
特别注意：当copy_len为0或者padding_len为0时，为0的CopyRow(都是默认值，全为零值)也是需要进行LookUp的（LookUp Copy中全为默认值行）
可参考代码如下：
insert_copy_lookup
在copy row cnt=2的位置分别NoPaddingCopyRow(vers[0]~vers[8])和PaddingCopyRow(vers[9]~vers[17])要lookUp的值
fn gen_witness(&self, trace: &GethExecStep, current_state: &mut WitnessExecHelper) -> Witness {
// ...
// 生成copy_rows
let (copy_rows, mem_rows, input_length, padding_length, code_copy_length) =
current_state.get_code_copy_rows_new(address, mem_offset, code_offset, size);
// default_copy_row：全为默认值的CopyRow
let mut default_copy_row = ¤t_state.get_none_copy_row();
if input_length > 0 && code_copy_length > 0 {
default_copy_row = ©_rows[0];
}
// default_padding_row：全为默认值的CopyRow
let mut default_padding_row = ¤t_state.get_none_copy_row();
if input_length > 0 && padding_length > 0 {
default_padding_row = ©_rows[code_copy_length as usize]
}
core_row_2.insert_copy_lookup_new(
default_copy_row,
default_padding_row,
code_copy_length,
padding_length,
);
// ...
}
pub fn insert_copy_lookup_new(
&mut self,
copy: ©::Row,
padding_copy: ©::Row,
copy_length: u64,
padding_length: u64,
) {
//
assert_eq!(self.cnt, 2.into());
for (cell, value) in [
// code copy
(&mut self.vers_0, Some((copy.src_type as u8).into())),
(&mut self.vers_1, Some(copy.src_id)),
(&mut self.vers_2, Some(copy.src_pointer)),
(&mut self.vers_3, copy.src_stamp),
(&mut self.vers_4, Some((copy.dst_type as u8).into())),
(&mut self.vers_5, Some(copy.dst_id)),
(&mut self.vers_6, Some(copy.dst_pointer)),
(&mut self.vers_7, Some(copy.dst_stamp)),
(&mut self.vers_8, Some(copy.len)),
// padding copy
(&mut self.vers_9, Some((padding_copy.src_type as u8).into())),
(&mut self.vers_10, Some(padding_copy.src_id)),
(&mut self.vers_11, Some(padding_copy.src_pointer)),
(&mut self.vers_12, padding_copy.src_stamp),
(
&mut self.vers_13,
Some((padding_copy.dst_type as u8).into()),
),
(&mut self.vers_14, Some(padding_copy.dst_id)),
(&mut self.vers_15, Some(padding_copy.dst_pointer)),
(&mut self.vers_16, Some(padding_copy.dst_stamp)),
(&mut self.vers_17, Some(padding_copy.len)),
// (&mut self.vers_18, Some(U256::from(copy_length))),
// (&mut self.vers_19, Some(U256::from(padding_length))),
//
] {
// before inserting, these columns must be none
assert!(cell.is_none());
*cell = value;
}
// ....
}
get_lookups
从copy row cnt=2的位置分别去NoPaddingCopyRow: vers[0]~vers[8]，PaddingCopyRow: vers[9]~vers[17]
fn get_lookups(
&self,
config: &ExecutionConfig<F, NUM_STATE_HI_COL, NUM_STATE_LO_COL>,
meta: &mut ConstraintSystem<F>,
) -> Vec<(String, LookupEntry<F>)> {
let stack_lookup_0 = query_expression(meta, |meta| config.get_state_lookup(meta, 0));
let stack_lookup_1 = query_expression(meta, |meta| config.get_state_lookup(meta, 1));
let stack_lookup_2 = query_expression(meta, |meta| config.get_state_lookup(meta, 2));
let stack_lookup_3 = query_expression(meta, |meta| config.get_state_lookup(meta, 3));
let copy_lookup = query_expression(meta, |meta| config.get_copy_lookup(meta));
let padding_copy_lookup =
query_expression(meta, |meta| config.get_copy_padding_lookup(meta));
vec![
("stack pop account address".into(), stack_lookup_0),
("stack pop mem offset".into(), stack_lookup_1),
("stack pop code offset".into(), stack_lookup_2),
("stack pop length".into(), stack_lookup_3),
("copy look up".into(), copy_lookup),
("padding look up".into(), padding_copy_lookup),
]
}