Finish the first memory impl and tests, stack tests, fixes validation

.gitignore

@@ -1,2 +1,3 @@
 nimcache/
 runner
+*_test

README.md

@@ -1,4 +1,5 @@
 # Nimbus
+
 An Ethereum 2.0 Sharding Client for Resource-Restricted Devices.
 
 https://docs.google.com/document/d/14u65XVNLOd83cq3t7wNC9UPweZ6kPWvmXwRTWWn0diQ/edit#

src/constants.nim

@@ -11,7 +11,13 @@ proc int256*(i: int): Int256 =
  i.initBigInt
 
 template i256*(i: int): Int256 =
- i.int256
+ i.initBigInt
+
+template i256*(i: Int256): Int256 =
+ i
+
+template getInt*(i: int): int =
+ i
 
 # TODO
 # We'll have a fast fixed i256, for now this works
@@ -77,7 +83,7 @@ mapOp(`xor`)
 proc `abs`*(a: Int256): Int256 =
  if a >= 0.i256: a else: -a
 
-proc `getInt`*(a: Int256): int =
+template `getInt`*(a: Int256): int =
  a.limbs[0].int
 
 let

src/validation.nim

@@ -1,5 +1,3 @@
-
-
 import
  strformat,
  errors, constants, bigints
@@ -8,27 +6,37 @@ proc validateCanonicalAddress*(value: string, title: string = "Value") =
  # TODO
  if false: #len(value) != 20:
  raise newException(ValidationError,
- fmt"{title} {value} is not a valid canonical address")
+ &"{title} {value} is not a valid canonical address")
+
 
 
 
+proc validateGte*(value: Int256 | int, minimum: int, title: string = "Value") =
+ if value.i256 < minimum.i256:
+ raise newException(ValidationError,
+ &"{title} {value} is not greater than or equal to {minimum}")
+
+proc validateGt*(value: Int256 | int, minimum: int, title: string = "Value") =
+ if value.i256 <= minimum.i256:
+ raise newException(ValidationError,
+ &"{title} {value} is not greater than {minimum}")
 
-proc validateGte*(value: Int256, minimum: int, title: string = "Value") =
- if value <= minimum.int256:
+proc validateLength*[T](values: seq[T], size: int) =
+ if values.len != size:
  raise newException(ValidationError,
- fmt"{title} {value} is not greater than or equal to {minimum}")
+ &"seq expected {size} len, got {values.len}")
 
-proc validateGte*(value: int, minimum: int, title: string = "Value") =
- if value <= minimum:
+proc validateLte*(value: Int256 | int, maximum: int, title: string = "Value") =
+ if value.i256 > maximum.i256:
  raise newException(ValidationError,
- fmt"{title} {value} is not greater than or equal to {minimum}")
+ &"{title} {value} is not less or equal to {maximum}")
 
-proc validateGt*(value: Int256, minimum: int, title: string = "Value") =
- if value < minimum.int256:
+proc validateLt*(value: Int256 | int, maximum: int, title: string = "Value") =
+ if value.i256 >= maximum.i256:
  raise newException(ValidationError,
- fmt"{title} {value} is not greater than or equal to {minimum}")
+ &"{title} {value} is not less than {maximum}")
 
-proc validateGt*(value: int, minimum: int, title: string = "Value") =
- if value < minimum:
+proc validateStackItem*(value: string) =
+ if value.len > 32:
  raise newException(ValidationError,
- fmt"{title} {value} is not greater than or equal to {minimum}")
+ &"Invalid stack item: expected 32 bytes, got {value.len}: value is {value}")

src/vm/memory.nim

@@ -13,7 +13,7 @@ proc newMemory*: Memory =
  result.logger = logging.getLogger("evm.vm.memory.Memory")
 
 proc len*(memory: Memory): int =
- result = len(memory.bytes)
+ result = memory.bytes.len
 
 proc extend*(memory: var Memory; startPosition: Int256; size: Int256) =
  if size == 0:
@@ -32,7 +32,19 @@ proc read*(memory: var Memory, startPosition: Int256, size: Int256): seq[byte] =
  result = memory.bytes[startPosition.getInt ..< (startPosition + size).getInt]
 
 proc write*(memory: var Memory, startPosition: Int256, size: Int256, value: seq[byte]) =
- echo value
+ if size == 0:
+ return
+ validateGte(startPosition, 0)
+ validateGte(size, 0)
+ validateLength(value, size.getInt)
+ validateLte(startPosition + size, memory.len)
+
+ let index = memory.len
+ if memory.len.i256 < startPosition + size:
+ memory.bytes = memory.bytes.concat(repeat(0.byte, memory.len - (startPosition + size).getInt)) # TODO: better logarithmic scaling?
+
+ for z, b in value:
+ memory.bytes[z + startPosition.getInt] = b
 
 template write*(memory: var Memory, startPosition: Int256, size: Int256, value: cstring) =
  memory.write(startPosition, size, value.toBytes)

src/vm/stack.nim

@@ -19,24 +19,31 @@ proc len*(stack: Stack): int =
 proc push*(stack: var Stack; value: Value) =
  ## Push an item onto the stack
  ensureStackLimit()
+ if value.kind == VInt:
+ validateGte(value.i, 0)
+ else:
+ validateStackItem(value.b)
 
  stack.values.add(value)
 
 proc push*(stack: var Stack; value: int) =
  ## Push an integer onto the stack
  ensureStackLimit()
-
+ validateGte(value, 0)
+
  stack.values.add(Value(kind: VInt, i: value.int256))
 
 proc push*(stack: var Stack; value: Int256) =
  ## Push an integer onto the stack
  ensureStackLimit()
+ validateGte(value, 0)
 
  stack.values.add(Value(kind: VInt, i: value))
 
 proc push*(stack: var Stack; value: string) =
  ## Push a binary onto the stack
  ensureStackLimit()
+ validateStackItem(value)
 
  stack.values.add(Value(kind: VBinary, b: value))
 
@@ -159,10 +166,10 @@ proc swap*(stack: var Stack; position: int) =
  raise newException(InsufficientStack,
  &"Insufficient stack items for SWAP{position}")
 
-proc dup*(stack: var Stack; position: int) =
+proc dup*(stack: var Stack; position: int | Int256) =
  ## Perform a DUP operation on the stack
- if position < len(stack) + 1:
- stack.push(stack.values[^position])
+ if (position != 0 and position.getInt < stack.len + 1) or (position == 0 and position.getInt < stack.len):
+ stack.push(stack.values[^position.getInt])
  else:
  raise newException(InsufficientStack,
  &"Insufficient stack items for DUP{position}")

src/vm/value.nim

@@ -28,3 +28,11 @@ proc vint*(i: Int256): Value =
 proc vbinary*(b: string): Value =
  Value(kind: VBinary, b: b)
 
+proc `==`*(a: Value, b: Value): bool =
+ if a.kind != b.kind:
+ return false
+ case a.kind:
+ of VInt:
+ a.i == b.i
+ of VBinary:
+ a.b == b.b

tests/memory_test.nim

@@ -0,0 +1,61 @@
+import unittest, macros, strformat, strutils, sequtils, constants, opcode_values, errors, vm / memory, bigints
+
+proc memory32: Memory =
+ result = newMemory()
+ result.extend(0.i256, 32.i256)
+
+proc memory128: Memory =
+ result = newMemory()
+ result.extend(0.i256, 128.i256)
+
+suite "memory":
+ test "write":
+ var mem = memory32()
+ # Test that write creates 32byte string == value padded with zeros
+ mem.write(startPosition = 0.i256, size = 4.i256, value = @[1.byte, 0.byte, 1.byte, 0.byte])
+ check(mem.bytes == @[1.byte, 0.byte, 1.byte, 0.byte].concat(repeat(0.byte, 28)))
+
+ test "write rejects invalid position":
+ expect(ValidationError):
+ var mem = memory32()
+ mem.write(startPosition = -1.i256, size = 2.i256, value = @[1.byte, 0.byte])
+ expect(ValidationError):
+ var mem = memory32()
+ mem.write(startPosition = pow(2.i256, 256), size = 2.i256, value = @[1.byte, 0.byte])
+
+ test "write rejects invalid size":
+ expect(ValidationError):
+ var mem = memory32() 
+ mem.write(startPosition = 0.i256, size = -1.i256, value = @[1.byte, 0.byte])
+ expect(ValidationError):
+ var mem = memory32()
+ mem.write(startPosition = 0.i256, size = pow(2.i256, 256), value = @[1.byte, 0.byte])
+
+ test "write rejects invalid value":
+ expect(ValidationError):
+ var mem = memory32()
+ mem.write(startPosition = 0.i256, size = 4.i256, value = @[1.byte, 0.byte])
+
+ test "write rejects valyes beyond memory size":
+ expect(ValidationError):
+ var mem = memory128()
+ mem.write(startPosition = 128.i256, size = 4.i256, value = @[1.byte, 0.byte, 1.byte, 0.byte])
+
+ test "extends appropriately extends memory":
+ var mem = newMemory()
+ # Test extends to 32 byte array: 0 < (start_position + size) <= 32
+ mem.extend(startPosition = 0.i256, size = 10.i256)
+ check(mem.bytes == repeat(0.byte, 32))
+ # Test will extend past length if params require: 32 < (start_position + size) <= 64
+ mem.extend(startPosition = 28.i256, size = 32.i256)
+ check(mem.bytes == repeat(0.byte, 64))
+ # Test won't extend past length unless params require: 32 < (start_position + size) <= 64
+ mem.extend(startPosition = 48.i256, size = 10.i256)
+ check(mem.bytes == repeat(0.byte, 64))
+
+ test "read returns correct bytes":
+ var mem = memory32()
+ mem.write(startPosition = 5.i256, size = 4.i256, value = @[1.byte, 0.byte, 1.byte, 0.byte])
+ check(mem.read(startPosition = 5.i256, size = 4.i256) == @[1.byte, 0.byte, 1.byte, 0.byte])
+ check(mem.read(startPosition = 6.i256, size = 4.i256) == @[0.byte, 1.byte, 0.byte, 0.byte])
+ check(mem.read(startPosition = 1.i256, size = 3.i256) == @[0.byte, 0.byte, 0.byte])

tests/stack_test.nim

@@ -0,0 +1,77 @@
+import unittest, macros, strformat, strutils, sequtils, constants, opcode_values, errors, vm / [stack, value], bigints
+
+suite "stack":
+ test "push only valid":
+ for value in @[0.vint, (pow(2.i256, 256) - 1.i256).vint, "ves".vbinary]:
+ var stack = newStack()
+ stack.push(value)
+ check(stack.values == @[value])
+
+ for value in @[(-1).vint, (-2).vint, "yzyzyzyzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz".vbinary]:
+ var stack = newStack()
+ expect(ValidationError):
+ stack.push(value)
+
+ test "push does not allow stack to exceed 1024":
+ var stack = newStack()
+ for z in 0 .. < 1024:
+ stack.push(z)
+ check(stack.len == 1024)
+ expect(FullStack):
+ stack.push(1025)
+
+ test "dup does not allow stack to exceed 1024":
+ var stack = newStack()
+ stack.push(1.i256)
+ for z in 0 ..< 1023:
+ stack.dup(1.i256)
+ check(stack.len == 1024)
+ expect(FullStack):
+ stack.dup(1.i256)
+
+ test "pop returns latest stack item":
+ var stack = newStack()
+ for element in @[1.vint, 2.vint, 3.vint]:
+ stack.push(element)
+ check(stack.popInt == 3)
+
+ stack = newStack()
+ for element in @["1".vbinary]:
+ stack.push(element)
+ check(stack.popBinary == "1")
+
+
+ test "swap correct":
+ var stack = newStack()
+ for z in 0 ..< 5:
+ stack.push(z)
+ check(stack.values == @[0.vint, 1.vint, 2.vint, 3.vint, 4.vint])
+ stack.swap(3)
+ check(stack.values == @[0.vint, 4.vint, 2.vint, 3.vint, 1.vint])
+ stack.swap(1)
+ check(stack.values == @[0.vint, 4.vint, 2.vint, 1.vint, 3.vint])
+
+ test "dup correct":
+ var stack = newStack()
+ for z in 0 ..< 5:
+ stack.push(z)
+ check(stack.values == @[0.vint, 1.vint, 2.vint, 3.vint, 4.vint])
+ stack.dup(1)
+ check(stack.values == @[0.vint, 1.vint, 2.vint, 3.vint, 4.vint, 4.vint])
+ stack.dup(5)
+ check(stack.values == @[0.vint, 1.vint, 2.vint, 3.vint, 4.vint, 4.vint, 1.vint])
+
+ test "pop raises InsufficientStack appropriately":
+ var stack = newStack()
+ expect(InsufficientStack):
+ discard stack.popInt()
+
+ test "swap raises InsufficientStack appropriately":
+ var stack = newStack()
+ expect(InsufficientStack):
+ stack.swap(0)
+
+ test "dup raises InsufficientStack appropriately":
+ var stack = newStack()
+ expect(InsufficientStack):
+ stack.dup(0)

tests/test.sh

@@ -2,5 +2,10 @@
 
 nim c tests/code_stream_test.nim
 nim c tests/gas_meter_test.nim
+nim c tests/memory_test.nim
+nim c tests/stack_test.nim
 ./tests/code_stream_test
 ./tests/gas_meter_test
+./tests/memory_test
+./tests/stack_test
+