Implement Patch::memory_limit

Author: sorpaas

src/lib.rs

@@ -116,10 +116,10 @@ pub trait VM {
 
 /// A sequencial VM. It uses sequencial memory representation and hash
 /// map storage for accounts.
-pub type SeqContextVM<P> = ContextVM<SeqMemory, P>;
+pub type SeqContextVM<P> = ContextVM<SeqMemory<P>, P>;
 /// A sequencial transaction VM. This is same as `SeqContextVM` except
 /// it runs at transaction level.
-pub type SeqTransactionVM<P> = TransactionVM<SeqMemory, P>;
+pub type SeqTransactionVM<P> = TransactionVM<SeqMemory<P>, P>;
 
 /// A VM that executes using a context and block information.
 pub struct ContextVM<M, P: Patch> {

src/memory.rs

@@ -3,6 +3,8 @@
 use bigint::{U256, M256};
 
 use super::errors::NotSupportedError;
+use super::Patch;
+use std::marker::PhantomData;
 
 /// Represent a memory in EVM. Read should always succeed. Write can
 /// fall.
@@ -28,28 +30,30 @@ pub trait Memory {
 
 /// A sequencial memory. It uses Rust's `Vec` for internal
 /// representation.
-pub struct SeqMemory {
+pub struct SeqMemory<P: Patch> {
     memory: Vec<u8>,
+    _marker: PhantomData<P>,
 }
 
-impl Default for SeqMemory {
-    fn default() -> SeqMemory {
+impl<P: Patch> Default for SeqMemory<P> {
+    fn default() -> SeqMemory<P> {
         SeqMemory {
             memory: Vec::new(),
+            _marker: PhantomData,
         }
     }
 }
 
-impl SeqMemory {
+impl<P: Patch> SeqMemory<P> {
     pub fn len(&self) -> usize {
         self.memory.len()
     }
 }
 
-impl Memory for SeqMemory {
+impl<P: Patch> Memory for SeqMemory<P> {
     fn check_write(&self, index: U256) -> Result<(), NotSupportedError> {
         let end = index + 32.into();
-        if end > U256::from(usize::max_value()) {
+        if end > U256::from(P::memory_limit()) {
             Err(NotSupportedError::MemoryIndexNotSupported)
         } else {
             Ok(())
@@ -61,7 +65,7 @@ impl Memory for SeqMemory {
             return Ok(());
         }
 
-        if M256::from(start) + M256::from(len) < M256::from(start) {
+        if start.saturating_add(len) > U256::from(P::memory_limit()) {
             Err(NotSupportedError::MemoryIndexNotSupported)
         } else {
             self.check_write(start + len - U256::from(1u64))
@@ -70,7 +74,7 @@ impl Memory for SeqMemory {
 
     fn write(&mut self, index: U256, value: M256) -> Result<(), NotSupportedError> {
         let end = M256::from(index) + 32.into();
-        if end > M256::from(usize::max_value()) {
+        if end > M256::from(P::memory_limit()) {
             return Err(NotSupportedError::MemoryIndexNotSupported);
         }
 
@@ -81,7 +85,7 @@ impl Memory for SeqMemory {
     }
 
     fn write_raw(&mut self, index: U256, value: u8) -> Result<(), NotSupportedError> {
-        if index > U256::from(usize::max_value()) {
+        if index > U256::from(P::memory_limit()) {
             return Err(NotSupportedError::MemoryIndexNotSupported);
         }
 

src/patch/mod.rs

@@ -41,6 +41,8 @@ pub trait Patch {
     /// If true, only consume at maximum l64(after_gas) when
     /// CALL/CALLCODE/DELEGATECALL.
     fn call_create_l64_after_gas() -> bool;
+    /// Maximum size of the memory, in bytes.
+    fn memory_limit() -> usize;
     /// Precompiled contracts at given address, with required code,
     /// and its definition.
     fn precompileds() -> &'static [(Address, Option<&'static [u8]>, Box<Precompiled>)];
@@ -79,6 +81,7 @@ impl Patch for FrontierPatch {
     fn has_delegate_call() -> bool { false }
     fn err_on_call_with_more_gas() -> bool { true }
     fn call_create_l64_after_gas() -> bool { false }
+    fn memory_limit() -> usize { usize::max_value() }
     fn precompileds() -> &'static [(Address, Option<&'static [u8]>, Box<Precompiled>)] {
         ETC_PRECOMPILEDS.deref() }
 }
@@ -99,6 +102,7 @@ impl Patch for HomesteadPatch {
     fn has_delegate_call() -> bool { true }
     fn err_on_call_with_more_gas() -> bool { true }
     fn call_create_l64_after_gas() -> bool { false }
+    fn memory_limit() -> usize { usize::max_value() }
     fn precompileds() -> &'static [(Address, Option<&'static [u8]>, Box<Precompiled>)] {
         ETC_PRECOMPILEDS.deref() }
 }
@@ -119,6 +123,7 @@ impl Patch for VMTestPatch {
     fn has_delegate_call() -> bool { false }
     fn err_on_call_with_more_gas() -> bool { true }
     fn call_create_l64_after_gas() -> bool { false }
+    fn memory_limit() -> usize { usize::max_value() }
     fn precompileds() -> &'static [(Address, Option<&'static [u8]>, Box<Precompiled>)] {
         ETC_PRECOMPILEDS.deref() }
 }
@@ -139,6 +144,7 @@ impl Patch for EIP150Patch {
     fn has_delegate_call() -> bool { true }
     fn err_on_call_with_more_gas() -> bool { false }
     fn call_create_l64_after_gas() -> bool { true }
+    fn memory_limit() -> usize { usize::max_value() }
     fn precompileds() -> &'static [(Address, Option<&'static [u8]>, Box<Precompiled>)] {
         ETC_PRECOMPILEDS.deref() }
 }
@@ -159,6 +165,7 @@ impl Patch for EIP160Patch {
     fn has_delegate_call() -> bool { true }
     fn err_on_call_with_more_gas() -> bool { false }
     fn call_create_l64_after_gas() -> bool { true }
+    fn memory_limit() -> usize { usize::max_value() }
     fn precompileds() -> &'static [(Address, Option<&'static [u8]>, Box<Precompiled>)] {
         ETC_PRECOMPILEDS.deref() }
 }