codecopy

Author: AntoineCyr

crypto3/libs/blueprint/include/nil/blueprint/zkevm_bbf/input_generators/basic_evm.hpp

@@ -1528,33 +1528,36 @@ namespace nil {
                 virtual void codecopy() {
                     // 6M memory bytes gives 60M+ gas cost
                     // max gas cost is 36M for now, might go up to 60M
-                    constexpr static const std::size_t max_dest_offset = 8388608;  // 2^23
-                    // max contract size is 24,576 bytes, so offset and length need to fit in
-                    // first chunk
+                    constexpr static const std::size_t max_dest_offset = 1 << 22;
+                    constexpr static const std::size_t max_length = 1 << 22;
+                    //  max contract size is 24,576 bytes, so offset need to fit in first chunk
                     constexpr static const std::size_t max_offset = 65536;
-                    constexpr static const std::size_t max_length = 65536;
-                    std::size_t dst = std::size_t(stack.back()); stack.pop_back();
-                    std::size_t src = std::size_t(stack.back()); stack.pop_back();
-                    std::size_t length = std::size_t(stack.back()); stack.pop_back();
 
-                    bool overflow = (dst > max_dest_offset) ||
-                                    (src > max_offset) ||
-                                    (length > max_length);
+                    auto dst = stack.back(); stack.pop_back();
+                    auto src = stack.back(); stack.pop_back();
+                    auto lgt = stack.back(); stack.pop_back();
 
-                    std::size_t minimum_word_size = (length + 31) / 32;
-                    std::size_t next_mem = std::max(dst + length, memory.size());
-                    std::size_t memory_expansion = memory_expansion_cost(next_mem, memory.size());
-                    std::size_t next_memory_size = memory_size_word_util(next_mem) * 32;
+                    bool overflow = (dst > max_dest_offset) ||
+                                    (lgt > max_length);
 
 
                     if (overflow) {
-                        memory.resize(memory.size() - 1);
-                        increase_gas(1);
+                        decrease_gas(gas + 1);
+                        memory.clear();
                     }
                     else {
-                        if( memory.size() < dst + length) memory.resize(next_memory_size);
+                        std::size_t distance = std::size_t(dst);
+                        std::size_t length = std::size_t(lgt);
+                        std::size_t source = src < max_offset ? std::size_t(src) : max_offset;
+
+                        std::size_t minimum_word_size = (length + 31) / 32;
+                        std::size_t next_mem = std::max(distance + length, memory.size());
+                        std::size_t memory_expansion = memory_expansion_cost(next_mem, memory.size());
+                        std::size_t next_memory_size = memory_size_word_util(next_mem) * 32;
+
+                        if( memory.size() < distance + length) memory.resize(next_memory_size);
                         for( std::size_t i = 0; i < length; i++){
-                            memory[dst+i] = src + i < bytecode.size()? bytecode[src+i]: 0;
+                            memory[distance+i] = source + i < bytecode.size()? bytecode[source+i]: 0;
                         }
                         decrease_gas(3 + 3 * minimum_word_size + memory_expansion); //dynamic gas
                     }

crypto3/libs/blueprint/include/nil/blueprint/zkevm_bbf/input_generators/basic_input_generator.hpp

@@ -989,28 +989,33 @@ namespace nil {
                 }
 
                 virtual void codecopy() override{
-                    std::size_t dst = std::size_t(stack[stack.size() - 1]);
-                    std::size_t src = std::size_t(stack[stack.size() - 2]);
-                    std::size_t length = std::size_t(stack[stack.size() - 3]);
+                    constexpr static const std::size_t max_offset = 65536;
+                    auto dst = stack[stack.size() - 1];
+                    auto src = stack[stack.size() - 2];
+                    auto lgt = stack[stack.size() - 3];
 
                     _zkevm_states.back().load_stack(stack, 3);
                     append_stack_reads(3);
 
                     zkevm_basic_evm::codecopy();
-                    if (memory.size() % 32 == 0) {
+                    if (memory.size() != 0) {
+                        std::size_t distance = std::size_t(dst);
+                        std::size_t length = std::size_t(lgt);
+                        std::size_t source = src < max_offset ? std::size_t(src) : max_offset;
+
                         copy_event cpy = codecopy_copy_event(
-                        bytecode_hash,
-                        src,
-                        call_id,
-                        dst,
-                        rw_counter,
-                        length
-                    );
+                            bytecode_hash,
+                            source,
+                            call_id,
+                            distance,
+                            rw_counter,
+                            length
+                        );
                         for( std::size_t i = 0; i < length; i++){
                             _short_rw_operations.push_back(memory_rw_operation(
-                                call_id, dst + i, rw_counter++, true, memory[dst + i]
+                                call_id, distance + i, rw_counter++, true, memory[distance + i]
                             ));
-                            cpy.push_byte(memory[dst+i]);
+                            cpy.push_byte(memory[distance+i]);
                         }
                         if( length > 0 ) _copy_events.push_back(cpy);
                     }