neo-go/docs/vm.md
2021-09-09 13:45:10 +03:00

234 lines
5.3 KiB
Markdown

# NEO-GO-VM
A cross platform virtual machine implementation for `NEF` compatible programs.
# Installation
VM is provided as part of neo-go binary, so usual neo-go build instructions
are applicable.
# Running the VM
Start the virtual machine:
```
$ ./bin/neo-go vm
_ ____________ __________ _ ____ ___
/ | / / ____/ __ \ / ____/ __ \ | | / / |/ /
/ |/ / __/ / / / /_____/ / __/ / / /____| | / / /|_/ /
/ /| / /___/ /_/ /_____/ /_/ / /_/ /_____/ |/ / / / /
/_/ |_/_____/\____/ \____/\____/ |___/_/ /_/
NEO-GO-VM >
```
# Usage
```
_ ____________ __________ _ ____ ___
/ | / / ____/ __ \ / ____/ __ \ | | / / |/ /
/ |/ / __/ / / / /_____/ / __/ / / /____| | / / /|_/ /
/ /| / /___/ /_/ /_____/ /_/ / /_/ /_____/ |/ / / / /
/_/ |_/_____/\____/ \____/\____/ |___/_/ /_/
NEO-GO-VM > help
Commands:
aslot Show arguments slot contents
break Place a breakpoint
clear clear the screen
cont Continue execution of the current loaded script
estack Show evaluation stack contents
exit Exit the VM prompt
help display help
ip Show current instruction
istack Show invocation stack contents
loadbase64 Load a base64-encoded script string into the VM
loadgo Compile and load a Go file with the manifest into the VM
loadhex Load a hex-encoded script string into the VM
loadnef Load a NEF-consistent script into the VM
lslot Show local slot contents
ops Dump opcodes of the current loaded program
parse Parse provided argument and convert it into other possible formats
run Execute the current loaded script
sslot Show static slot contents
step Step (n) instruction in the program
stepinto Stepinto instruction to take in the debugger
stepout Stepout instruction to take in the debugger
stepover Stepover instruction to take in the debugger
```
You can get help for each command and its parameters adding `help` as a
parameter to the command:
```
NEO-GO-VM > step help
Usage: step [<n>]
<n> is optional parameter to specify number of instructions to run, example:
> step 10
```
## Loading in your script
To load an avm script in NEF format into the VM:
```
NEO-GO-VM > loadnef ../contract.nef
READY: loaded 36 instructions
```
Run the script:
```
NEO-GO-VM > run
[
{
"value": 1,
"type": "BigInteger"
}
]
```
You can also directly compile and load `.go` files:
```
NEO-GO-VM > loadgo ../contract.go
READY: loaded 36 instructions
```
To make it even more complete, you can directly load hex or base64 strings into the VM:
```
NEO-GO-VM > loadhex 54c56b006c766b00527ac46c766b00c391640b006203005a616c756662030000616c7566
READY: loaded 36 instructions
NEO-GO-VM > run
[
{
"value": 10,
"type": "BigInteger"
}
]
```
## Running programs with arguments
You can invoke smart contracts with arguments. Take the following ***roll the dice*** smartcontract as example.
```
package rollthedice
import "github.com/nspcc-dev/neo-go/pkg/interop/runtime"
func RollDice(number int) {
if number == 0 {
runtime.Log("you rolled 0, better luck next time!")
}
if number == 1 {
runtime.Log("you rolled 1, still better then 0!")
}
if number == 2 {
runtime.Log("you rolled 2, coming closer..")
}
if number == 3 {
runtime.Log("Sweet you rolled 3. This dice has only 3 sides o_O")
}
}
```
To invoke this contract we need to specify both the method and the arguments.
The first parameter (called method or operation) is always of type
string. Notice that arguments can have different types, they can inferred
automatically (please refer to the `run` command help), but in you need to
pass parameter of specific type you can specify it in `run`'s arguments:
```
NEO-GO-VM > run rollDice int:1
```
> The method is always of type string, hence we don't need to specify the type.
To add more than 1 argument:
```
NEO-GO-VM > run someMethod int:1 int:2 string:foo string:bar
```
Currently supported types:
- `bool (bool:false and bool:true)`
- `int (int:1 int:100)`
- `string (string:foo string:this is a string)`
## Debugging
The `neo-go-vm` provides a debugger to inspect your program in-depth.
### Stepping through the program
Step 4 instructions.
```
NEO-GO-VM > step 4
at breakpoint 3 (DUPFROMALTSTACK)
NEO-GO-VM 3 >
```
Using just `step` will execute 1 instruction at a time.
```
NEO-GO-VM 3 > step
at breakpoint 4 (PUSH0)
NEO-GO-VM 4 >
```
### Breakpoints
To place breakpoints:
```
NEO-GO-VM > break 10
breakpoint added at instruction 10
NEO-GO-VM > cont
at breakpoint 10 (SETITEM)
NEO-GO-VM 10 > cont
```
## Inspecting stack
Inspecting the evaluation stack:
```
NEO-GO-VM > estack
[
{
"value": [
null,
null,
null,
null,
null,
null,
null
],
"type": "Array"
},
{
"value": 4,
"type": "BigInteger"
}
]
```
There is one more stack that you can inspect.
- `istack` invocation stack
There are slots that you can inspect.
- `aslot` dumps arguments slot contents.
- `lslot` dumps local slot contents.
- `sslot` dumps static slot contents.