Close #444: Add evm debugger

build.sbt

@@ -152,7 +152,7 @@ lazy val `vm-asm` = (project in file("vm-asm"))
 
 lazy val evm = (project in file("evm")).
   dependsOn(`vm-asm`).
-  dependsOn(vm % "test->test").
+  dependsOn(vm  % "compile->compile;test->test").
   settings(normalizedName := "pravda-evm").
   settings( commonSettings: _* ).
   settings(

doc/standard-library/read-evm-word.md

@@ -0,0 +1,15 @@
+<!--
+THIS FILE IS GENERATED. DO NOT EDIT MANUALLY!
+-->
+## ReadEvmWord
+
+### Id
+
+`0x06`
+### Signature
+
+`(index: bigint, array: array): bytes`
+
+### Description
+
+Takes byte array, index from stack. Returns 32 bytes, truncated if necessary, from given index in the given array.

doc/standard-library/slice-evm-memory.md

@@ -0,0 +1,15 @@
+<!--
+THIS FILE IS GENERATED. DO NOT EDIT MANUALLY!
+-->
+## SliceEvmMemory
+
+### Id
+
+`0x08`
+### Signature
+
+`(size: bigint, ind: bigint, array: array): bytes`
+
+### Description
+
+Takes byte array, index, size stack. Returns slice of the array between ind and ind + size.

doc/standard-library/write-evm-word.md

@@ -0,0 +1,15 @@
+<!--
+THIS FILE IS GENERATED. DO NOT EDIT MANUALLY!
+-->
+## WriteEvmWord
+
+### Id
+
+`0x07`
+### Signature
+
+`(bytes: bytes, index: bigint, array: array): array`
+
+### Description
+
+Takes byte array, index from stack, bytes to write. Writes 32 bytes, fill with zeros if necessary, from given index in the given array. Returns reference to array

evm/src/main/scala/pravda/evm/debug/DebugVm.scala

@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2018  Expload.com
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package pravda.evm.debug
+
+import java.nio.ByteBuffer
+
+import com.google.protobuf.ByteString
+import pravda.common.domain
+import pravda.common.domain.Address
+import pravda.vm._
+import pravda.vm.impl.MemoryImpl
+import pravda.vm.sandbox.VmSandbox.StorageSandbox
+
+//'extends Vm' is required for using 'this' in SystemOperation constructor
+trait DebugVm extends Vm {
+  override def spawn(initialProgram: ByteString, environment: Environment, wattLimit: Long): ExecutionResult =
+    throw new Exception("It's debug vm")
+
+  override def run(programAddress: Address,
+                   environment: Environment,
+                   memory: Memory,
+                   wattCounter: WattCounter,
+                   pcallAllowed: Boolean): Unit =
+    throw new Exception("It's debug vm. You can't use pcall, lcall opcodes")
+
+  def debugBytes[S](program: ByteBuffer,
+                    env: Environment,
+                    mem: MemoryImpl,
+                    counter: WattCounter,
+                    maybeStorage: Option[StorageSandbox],
+                    maybePA: Option[domain.Address],
+                    pcallAllowed: Boolean)(implicit debugger: Debugger[S]): List[S]
+}
+
+object DebugVm {
+
+  sealed trait ExecutionResult
+
+  final case class UnitExecution(f: () => Unit) extends ExecutionResult {
+    f()
+  }
+
+  case object InterruptedExecution extends ExecutionResult
+
+  final case class MetaExecution(meta: Meta) extends ExecutionResult
+
+}

evm/src/main/scala/pravda/evm/debug/Debugger.scala

@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2018  Expload.com
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package pravda.evm.debug
+
+import java.nio.ByteBuffer
+
+import pravda.evm.debug.DebugVm.ExecutionResult
+import pravda.vm.impl.MemoryImpl
+import pravda.vm.sandbox.VmSandbox.StorageSandbox
+
+trait Debugger[State] {
+
+  def debugOp(program: ByteBuffer, op: Int, mem: MemoryImpl, storage: StorageSandbox)(
+      execResult: Either[Throwable, ExecutionResult]): State
+}

evm/src/main/scala/pravda/evm/debug/VmImplDebug.scala

@@ -0,0 +1,152 @@
+/*
+ * Copyright (C) 2018  Expload.com
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package pravda.evm.debug
+
+import java.nio.ByteBuffer
+
+import pravda.common.domain
+import pravda.vm.Error.PcallDenied
+import pravda.vm.Opcodes._
+import pravda.vm.WattCounter.CpuBasic
+import pravda.vm._
+import pravda.vm.impl.MemoryImpl
+import pravda.vm.operations._
+
+import scala.annotation.tailrec
+import scala.util.Try
+import pravda.evm.debug.DebugVm.{InterruptedExecution, MetaExecution, UnitExecution}
+import pravda.vm.sandbox.VmSandbox.StorageSandbox
+
+class VmImplDebug extends DebugVm {
+
+  def debugBytes[S](program: ByteBuffer,
+                    env: Environment,
+                    mem: MemoryImpl,
+                    counter: WattCounter,
+                    maybeStorage: Option[StorageSandbox],
+                    maybePA: Option[domain.Address],
+                    pcallAllowed: Boolean)(implicit debugger: Debugger[S]): List[S] = {
+
+    val logicalOperations = new LogicalOperations(mem, counter)
+    val arithmeticOperations = new ArithmeticOperations(mem, counter)
+    val storageOperations = new StorageOperations(mem, maybeStorage, counter)
+    val heapOperations = new HeapOperations(mem, program, counter)
+    val stackOperations = new StackOperations(mem, program, counter)
+    val controlOperations = new ControlOperations(program, mem, counter)
+    val nativeCoinOperations = new NativeCoinOperations(mem, env, counter, maybePA)
+    val systemOperations =
+      new SystemOperations(program, mem, maybeStorage, counter, env, maybePA, StandardLibrary.Index, this)
+    val dataOperations = new DataOperations(mem, counter)
+
+    val Some(storage) = maybeStorage
+
+    @tailrec def proc(acc: List[S]): List[S] = {
+      counter.cpuUsage(CpuBasic)
+      val op = program.get() & 0xff
+
+      import DebugVm.ExecutionResult
+      val executionResult = Try[ExecutionResult] {
+        mem.setCounter(program.position())
+        op match {
+          // Control operations
+          case CALL  => UnitExecution(() => controlOperations.call())
+          case RET   => UnitExecution(() => controlOperations.ret())
+          case JUMP  => UnitExecution(() => controlOperations.jump())
+          case JUMPI => UnitExecution(() => controlOperations.jumpi())
+          // Native coin operations
+          case TRANSFER  => UnitExecution(() => nativeCoinOperations.transfer())
+          case PTRANSFER => UnitExecution(() => nativeCoinOperations.ptransfer())
+          case BALANCE   => UnitExecution(() => nativeCoinOperations.balance())
+          // Stack operations
+          case POP   => UnitExecution(() => stackOperations.pop())
+          case PUSHX => UnitExecution(() => stackOperations.push())
+          case DUP   => UnitExecution(() => stackOperations.dup())
+          case DUPN  => UnitExecution(() => stackOperations.dupN())
+          case SWAP  => UnitExecution(() => stackOperations.swap())
+          case SWAPN => UnitExecution(() => stackOperations.swapN())
+          // Heap operations
+          case NEW               => UnitExecution(() => heapOperations.`new`())
+          case ARRAY_GET         => UnitExecution(() => heapOperations.arrayGet())
+          case STRUCT_GET        => UnitExecution(() => heapOperations.structGet())
+          case STRUCT_GET_STATIC => UnitExecution(() => heapOperations.structGetStatic())
+          case ARRAY_MUT         => UnitExecution(() => heapOperations.arrayMut())
+          case STRUCT_MUT        => UnitExecution(() => heapOperations.structMut())
+          case STRUCT_MUT_STATIC => UnitExecution(() => heapOperations.structMutStatic())
+          case PRIMITIVE_PUT     => UnitExecution(() => heapOperations.primitivePut())
+          case PRIMITIVE_GET     => UnitExecution(() => heapOperations.primitiveGet())
+          case NEW_ARRAY         => UnitExecution(() => heapOperations.newArray())
+          case LENGTH            => UnitExecution(() => heapOperations.length())
+          // Storage operations
+          case SPUT   => UnitExecution(() => storageOperations.put())
+          case SGET   => UnitExecution(() => storageOperations.get())
+          case SDROP  => UnitExecution(() => storageOperations.drop())
+          case SEXIST => UnitExecution(() => storageOperations.exists())
+          // Arithmetic operations
+          case ADD => UnitExecution(() => arithmeticOperations.add())
+          case MUL => UnitExecution(() => arithmeticOperations.mul())
+          case DIV => UnitExecution(() => arithmeticOperations.div())
+          case MOD => UnitExecution(() => arithmeticOperations.mod())
+          // Logical operations
+          case NOT => UnitExecution(() => logicalOperations.not())
+          case AND => UnitExecution(() => logicalOperations.and())
+          case OR  => UnitExecution(() => logicalOperations.or())
+          case XOR => UnitExecution(() => logicalOperations.xor())
+          case EQ  => UnitExecution(() => logicalOperations.eq())
+          case LT  => UnitExecution(() => logicalOperations.lt())
+          case GT  => UnitExecution(() => logicalOperations.gt())
+          // Data operations
+          case CAST   => UnitExecution(() => dataOperations.cast())
+          case CONCAT => UnitExecution(() => dataOperations.concat())
+          case SLICE  => UnitExecution(() => dataOperations.slice())
+          // System operations
+          case STOP    => InterruptedExecution
+          case FROM    => UnitExecution(() => systemOperations.from())
+          case LCALL   => UnitExecution(() => systemOperations.lcall())
+          case SCALL   => UnitExecution(() => systemOperations.scall())
+          case PCREATE => UnitExecution(() => systemOperations.pcreate())
+          case SEAL    => UnitExecution(() => systemOperations.seal())
+          case PUPDATE => UnitExecution(() => systemOperations.pupdate())
+          case PADDR   => UnitExecution(() => systemOperations.paddr())
+          case PCALL =>
+            if (pcallAllowed) {
+              UnitExecution(() => systemOperations.pcall())
+            } else {
+              throw ThrowableVmError(PcallDenied)
+            }
+          case THROW   => UnitExecution(() => systemOperations.`throw`())
+          case EVENT   => UnitExecution(() => systemOperations.event())
+          case CALLERS => UnitExecution(() => systemOperations.callers())
+          case HEIGHT  => UnitExecution(() => systemOperations.chainHeight())
+          case HASH    => UnitExecution(() => systemOperations.lastBlockHash())
+          case CODE    => UnitExecution(() => systemOperations.code())
+          case META =>
+            MetaExecution(Meta.readFromByteBuffer(program))
+          case _ => UnitExecution(() => ())
+        }
+      }.toEither
+      val state = debugger.debugOp(program, op, mem, storage)(executionResult)
+      val res = state :: acc
+      executionResult match {
+        case Right(InterruptedExecution) | Left(_) =>
+          res
+        case _ => if (program.hasRemaining) proc(res) else res
+      }
+    }
+    proc(Nil).reverse
+  }
+}

evm/src/main/scala/pravda/evm/debug/VmSandboxDebug.scala

@@ -0,0 +1,76 @@
+/*
+ * Copyright (C) 2018  Expload.com
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package pravda.evm.debug
+
+import com.google.protobuf.ByteString
+import pravda.common.domain.Address
+import pravda.vm
+import pravda.vm._
+import pravda.vm.impl.{MemoryImpl, WattCounterImpl}
+import pravda.vm.sandbox.VmSandbox.{EnvironmentSandbox, Preconditions, StorageSandbox}
+
+import scala.collection.mutable
+import scala.collection.mutable.ArrayBuffer
+
+object VmSandboxDebug {
+
+  def run[S](input: Preconditions, code: ByteString)(implicit debugger: Debugger[S]): List[S] = {
+    val sandboxVm = new VmImplDebug()
+    val heap = {
+      if (input.heap.nonEmpty) {
+        val length = input.heap.map(_._1.data).max + 1
+        val buffer = ArrayBuffer.fill[Data](length)(Data.Primitive.Null)
+        input.heap.foreach { case (ref, value) => buffer(ref.data) = value }
+        buffer
+      } else {
+        ArrayBuffer[Data]()
+      }
+    }
+    val memory = MemoryImpl(ArrayBuffer(input.stack: _*), heap)
+    val wattCounter = new WattCounterImpl(input.`watts-limit`)
+
+    val pExecutor = input.executor.getOrElse {
+      Address @@ ByteString.copyFrom((1 to 32).map(_.toByte).toArray)
+    }
+
+    val effects = mutable.Buffer[vm.Effect]()
+    val environment: Environment = new EnvironmentSandbox(
+      effects,
+      input.`program-storage`,
+      input.balances.toSeq,
+      input.programs.toSeq,
+      pExecutor,
+      input.`app-state-info`
+    )
+    val storage = new StorageSandbox(Address.Void, effects, input.storage.toSeq)
+
+    memory.enterProgram(Address.Void)
+    val res = sandboxVm.debugBytes(
+      code.asReadOnlyByteBuffer(),
+      environment,
+      memory,
+      wattCounter,
+      Some(storage),
+      Some(Address.Void),
+      pcallAllowed = true
+    )
+    memory.exitProgram()
+    res
+
+  }
+}