2014-02-24 13:10:45 +02:00
|
|
|
package ethchain
|
|
|
|
|
|
|
|
import (
|
2014-04-11 20:29:57 +03:00
|
|
|
"fmt"
|
2014-06-29 20:30:05 +03:00
|
|
|
"github.com/ethereum/eth-go/ethcrypto"
|
2014-06-23 14:54:10 +03:00
|
|
|
"github.com/ethereum/eth-go/ethlog"
|
2014-06-26 20:45:57 +03:00
|
|
|
"github.com/ethereum/eth-go/ethutil"
|
2014-06-13 13:45:11 +03:00
|
|
|
"math"
|
2014-02-24 13:10:45 +02:00
|
|
|
"math/big"
|
|
|
|
)
|
|
|
|
|
2014-06-23 14:54:10 +03:00
|
|
|
var vmlogger = ethlog.NewLogger("VM")
|
|
|
|
|
2014-03-24 14:20:34 +02:00
|
|
|
var (
|
|
|
|
GasStep = big.NewInt(1)
|
|
|
|
GasSha = big.NewInt(20)
|
|
|
|
GasSLoad = big.NewInt(20)
|
|
|
|
GasSStore = big.NewInt(100)
|
|
|
|
GasBalance = big.NewInt(20)
|
|
|
|
GasCreate = big.NewInt(100)
|
|
|
|
GasCall = big.NewInt(20)
|
|
|
|
GasMemory = big.NewInt(1)
|
2014-06-13 13:45:11 +03:00
|
|
|
GasData = big.NewInt(5)
|
2014-05-22 18:35:26 +03:00
|
|
|
GasTx = big.NewInt(500)
|
2014-03-24 14:20:34 +02:00
|
|
|
)
|
|
|
|
|
2014-05-28 13:05:46 +03:00
|
|
|
func CalculateTxGas(initSize *big.Int) *big.Int {
|
2014-04-27 17:50:44 +03:00
|
|
|
totalGas := new(big.Int)
|
|
|
|
|
2014-05-28 13:05:46 +03:00
|
|
|
txTotalBytes := new(big.Int).Set(initSize)
|
2014-04-27 17:50:44 +03:00
|
|
|
txTotalBytes.Div(txTotalBytes, ethutil.Big32)
|
|
|
|
totalGas.Add(totalGas, new(big.Int).Mul(txTotalBytes, GasSStore))
|
|
|
|
|
|
|
|
return totalGas
|
|
|
|
}
|
|
|
|
|
2014-02-24 13:10:45 +02:00
|
|
|
type Vm struct {
|
|
|
|
// Stack for processing contracts
|
|
|
|
stack *Stack
|
|
|
|
// non-persistent key/value memory storage
|
|
|
|
mem map[string]*big.Int
|
|
|
|
|
|
|
|
vars RuntimeVars
|
2014-03-20 20:50:53 +02:00
|
|
|
|
|
|
|
state *State
|
2014-04-26 02:47:55 +03:00
|
|
|
|
|
|
|
stateManager *StateManager
|
2014-06-17 19:49:26 +03:00
|
|
|
|
|
|
|
Verbose bool
|
|
|
|
|
|
|
|
logStr string
|
2014-06-20 01:41:28 +03:00
|
|
|
|
|
|
|
err error
|
2014-07-02 02:04:21 +03:00
|
|
|
|
2014-07-02 14:08:32 +03:00
|
|
|
// Debugging
|
|
|
|
Hook DebugHook
|
|
|
|
BreakPoints []int64
|
|
|
|
Stepping bool
|
2014-07-04 16:32:10 +03:00
|
|
|
Fn string
|
2014-02-24 13:10:45 +02:00
|
|
|
}
|
|
|
|
|
2014-07-02 02:04:21 +03:00
|
|
|
type DebugHook func(step int, op OpCode, mem *Memory, stack *Stack, stateObject *StateObject) bool
|
|
|
|
|
2014-02-24 13:10:45 +02:00
|
|
|
type RuntimeVars struct {
|
2014-04-11 20:29:57 +03:00
|
|
|
Origin []byte
|
2014-06-19 14:45:29 +03:00
|
|
|
Block *Block
|
|
|
|
BlockNumber *big.Int
|
2014-04-11 20:29:57 +03:00
|
|
|
PrevHash []byte
|
|
|
|
Coinbase []byte
|
|
|
|
Time int64
|
|
|
|
Diff *big.Int
|
|
|
|
TxData []string
|
2014-05-07 12:05:49 +03:00
|
|
|
Value *big.Int
|
2014-02-24 13:10:45 +02:00
|
|
|
}
|
|
|
|
|
2014-06-17 19:49:26 +03:00
|
|
|
func (self *Vm) Printf(format string, v ...interface{}) *Vm {
|
|
|
|
if self.Verbose {
|
|
|
|
self.logStr += fmt.Sprintf(format, v...)
|
|
|
|
}
|
|
|
|
|
|
|
|
return self
|
|
|
|
}
|
|
|
|
|
|
|
|
func (self *Vm) Endl() *Vm {
|
|
|
|
if self.Verbose {
|
2014-07-03 17:07:21 +03:00
|
|
|
vmlogger.Debugln(self.logStr)
|
2014-06-17 19:49:26 +03:00
|
|
|
self.logStr = ""
|
|
|
|
}
|
|
|
|
|
|
|
|
return self
|
|
|
|
}
|
|
|
|
|
2014-04-26 02:47:55 +03:00
|
|
|
func NewVm(state *State, stateManager *StateManager, vars RuntimeVars) *Vm {
|
|
|
|
return &Vm{vars: vars, state: state, stateManager: stateManager}
|
2014-03-20 20:50:53 +02:00
|
|
|
}
|
|
|
|
|
2014-03-21 12:54:36 +02:00
|
|
|
var Pow256 = ethutil.BigPow(2, 256)
|
|
|
|
|
2014-04-15 23:16:38 +03:00
|
|
|
var isRequireError = false
|
|
|
|
|
2014-07-02 02:04:21 +03:00
|
|
|
func (vm *Vm) RunClosure(closure *Closure) (ret []byte, err error) {
|
2014-04-15 23:16:38 +03:00
|
|
|
// Recover from any require exception
|
|
|
|
defer func() {
|
2014-06-19 14:45:29 +03:00
|
|
|
if r := recover(); r != nil {
|
2014-04-15 23:16:38 +03:00
|
|
|
ret = closure.Return(nil)
|
|
|
|
err = fmt.Errorf("%v", r)
|
2014-06-23 14:54:10 +03:00
|
|
|
vmlogger.Errorln("vm err", err)
|
2014-04-15 23:16:38 +03:00
|
|
|
}
|
|
|
|
}()
|
|
|
|
|
2014-07-04 16:32:10 +03:00
|
|
|
vmlogger.Debugf("(%s) %x gas: %v (d) %x\n", vm.Fn, closure.object.Address(), closure.Gas, closure.Args)
|
2014-03-20 18:26:07 +02:00
|
|
|
|
2014-06-26 12:26:42 +03:00
|
|
|
var (
|
|
|
|
op OpCode
|
|
|
|
|
|
|
|
mem = &Memory{}
|
|
|
|
stack = NewStack()
|
|
|
|
pc = big.NewInt(0)
|
|
|
|
step = 0
|
|
|
|
prevStep = 0
|
|
|
|
require = func(m int) {
|
|
|
|
if stack.Len() < m {
|
|
|
|
isRequireError = true
|
|
|
|
panic(fmt.Sprintf("%04v (%v) stack err size = %d, required = %d", pc, op, stack.Len(), m))
|
|
|
|
}
|
2014-04-15 23:16:38 +03:00
|
|
|
}
|
2014-06-26 12:26:42 +03:00
|
|
|
)
|
2014-03-20 18:26:07 +02:00
|
|
|
|
|
|
|
for {
|
2014-05-28 13:05:46 +03:00
|
|
|
prevStep = step
|
2014-04-24 01:00:50 +03:00
|
|
|
// The base for all big integer arithmetic
|
|
|
|
base := new(big.Int)
|
|
|
|
|
2014-03-20 18:26:07 +02:00
|
|
|
step++
|
|
|
|
// Get the memory location of pc
|
2014-04-09 19:27:54 +03:00
|
|
|
val := closure.Get(pc)
|
2014-03-20 18:26:07 +02:00
|
|
|
// Get the opcode (it must be an opcode!)
|
2014-06-26 12:26:42 +03:00
|
|
|
op = OpCode(val.Uint())
|
2014-06-17 12:06:06 +03:00
|
|
|
|
2014-03-24 14:20:34 +02:00
|
|
|
gas := new(big.Int)
|
2014-06-13 17:06:27 +03:00
|
|
|
addStepGasUsage := func(amount *big.Int) {
|
2014-06-20 01:41:28 +03:00
|
|
|
if amount.Cmp(ethutil.Big0) >= 0 {
|
|
|
|
gas.Add(gas, amount)
|
|
|
|
}
|
2014-03-24 14:20:34 +02:00
|
|
|
}
|
|
|
|
|
2014-06-13 17:06:27 +03:00
|
|
|
addStepGasUsage(GasStep)
|
|
|
|
|
2014-06-13 13:45:11 +03:00
|
|
|
var newMemSize uint64 = 0
|
2014-03-24 14:20:34 +02:00
|
|
|
switch op {
|
2014-06-13 17:06:27 +03:00
|
|
|
case STOP:
|
2014-06-17 19:05:46 +03:00
|
|
|
gas.Set(ethutil.Big0)
|
2014-06-13 17:06:27 +03:00
|
|
|
case SUICIDE:
|
2014-06-17 19:05:46 +03:00
|
|
|
gas.Set(ethutil.Big0)
|
2014-05-28 13:05:46 +03:00
|
|
|
case SLOAD:
|
2014-06-13 17:06:27 +03:00
|
|
|
gas.Set(GasSLoad)
|
2014-05-28 13:05:46 +03:00
|
|
|
case SSTORE:
|
2014-03-24 14:20:34 +02:00
|
|
|
var mult *big.Int
|
|
|
|
y, x := stack.Peekn()
|
2014-07-02 01:06:21 +03:00
|
|
|
val := closure.GetStorage(x)
|
2014-03-24 14:20:34 +02:00
|
|
|
if val.IsEmpty() && len(y.Bytes()) > 0 {
|
|
|
|
mult = ethutil.Big2
|
|
|
|
} else if !val.IsEmpty() && len(y.Bytes()) == 0 {
|
|
|
|
mult = ethutil.Big0
|
|
|
|
} else {
|
|
|
|
mult = ethutil.Big1
|
|
|
|
}
|
2014-06-13 17:06:27 +03:00
|
|
|
gas = new(big.Int).Mul(mult, GasSStore)
|
2014-05-28 13:05:46 +03:00
|
|
|
case BALANCE:
|
2014-06-13 17:06:27 +03:00
|
|
|
gas.Set(GasBalance)
|
2014-06-13 13:45:11 +03:00
|
|
|
case MSTORE:
|
|
|
|
require(2)
|
|
|
|
newMemSize = stack.Peek().Uint64() + 32
|
2014-06-13 17:06:27 +03:00
|
|
|
case MLOAD:
|
|
|
|
|
2014-06-13 13:45:11 +03:00
|
|
|
case MSTORE8:
|
|
|
|
require(2)
|
|
|
|
newMemSize = stack.Peek().Uint64() + 1
|
|
|
|
case RETURN:
|
|
|
|
require(2)
|
|
|
|
|
|
|
|
newMemSize = stack.Peek().Uint64() + stack.data[stack.Len()-2].Uint64()
|
|
|
|
case SHA3:
|
|
|
|
require(2)
|
|
|
|
|
2014-06-13 17:06:27 +03:00
|
|
|
gas.Set(GasSha)
|
2014-06-13 13:45:11 +03:00
|
|
|
|
|
|
|
newMemSize = stack.Peek().Uint64() + stack.data[stack.Len()-2].Uint64()
|
|
|
|
case CALLDATACOPY:
|
2014-04-27 17:50:44 +03:00
|
|
|
require(3)
|
|
|
|
|
2014-06-13 13:45:11 +03:00
|
|
|
newMemSize = stack.Peek().Uint64() + stack.data[stack.Len()-3].Uint64()
|
|
|
|
case CODECOPY:
|
|
|
|
require(3)
|
2014-04-27 17:50:44 +03:00
|
|
|
|
2014-06-13 13:45:11 +03:00
|
|
|
newMemSize = stack.Peek().Uint64() + stack.data[stack.Len()-3].Uint64()
|
2014-05-28 13:05:46 +03:00
|
|
|
case CALL:
|
2014-06-13 13:45:11 +03:00
|
|
|
require(7)
|
2014-06-13 17:06:27 +03:00
|
|
|
gas.Set(GasCall)
|
2014-06-19 14:45:29 +03:00
|
|
|
addStepGasUsage(stack.data[stack.Len()-1])
|
2014-06-13 13:45:11 +03:00
|
|
|
|
|
|
|
x := stack.data[stack.Len()-6].Uint64() + stack.data[stack.Len()-7].Uint64()
|
|
|
|
y := stack.data[stack.Len()-4].Uint64() + stack.data[stack.Len()-5].Uint64()
|
|
|
|
|
|
|
|
newMemSize = uint64(math.Max(float64(x), float64(y)))
|
|
|
|
case CREATE:
|
|
|
|
require(3)
|
2014-06-13 17:06:27 +03:00
|
|
|
gas.Set(GasCreate)
|
2014-06-13 13:45:11 +03:00
|
|
|
|
|
|
|
newMemSize = stack.data[stack.Len()-2].Uint64() + stack.data[stack.Len()-3].Uint64()
|
2014-03-24 14:20:34 +02:00
|
|
|
}
|
2014-03-20 18:26:07 +02:00
|
|
|
|
2014-06-13 13:45:11 +03:00
|
|
|
newMemSize = (newMemSize + 31) / 32 * 32
|
|
|
|
if newMemSize > uint64(mem.Len()) {
|
|
|
|
m := GasMemory.Uint64() * (newMemSize - uint64(mem.Len())) / 32
|
2014-06-13 17:06:27 +03:00
|
|
|
addStepGasUsage(big.NewInt(int64(m)))
|
2014-06-13 13:45:11 +03:00
|
|
|
}
|
|
|
|
|
2014-05-28 13:05:46 +03:00
|
|
|
if !closure.UseGas(gas) {
|
2014-06-19 14:45:29 +03:00
|
|
|
err := fmt.Errorf("Insufficient gas for %v. req %v has %v", op, gas, closure.Gas)
|
2014-03-31 01:03:28 +02:00
|
|
|
|
2014-06-19 14:45:29 +03:00
|
|
|
closure.UseGas(closure.Gas)
|
|
|
|
|
|
|
|
return closure.Return(nil), err
|
2014-03-20 18:26:07 +02:00
|
|
|
}
|
2014-04-20 02:31:01 +03:00
|
|
|
|
2014-06-20 01:41:28 +03:00
|
|
|
vm.Printf("(pc) %-3d -o- %-14s", pc, op.String())
|
2014-06-17 19:49:26 +03:00
|
|
|
vm.Printf(" (g) %-3v (%v)", gas, closure.Gas)
|
|
|
|
|
2014-06-13 13:45:11 +03:00
|
|
|
mem.Resize(newMemSize)
|
|
|
|
|
2014-03-20 18:26:07 +02:00
|
|
|
switch op {
|
2014-05-28 13:05:46 +03:00
|
|
|
case LOG:
|
2014-03-21 12:54:36 +02:00
|
|
|
stack.Print()
|
|
|
|
mem.Print()
|
2014-04-15 23:16:38 +03:00
|
|
|
// 0x20 range
|
2014-05-28 13:05:46 +03:00
|
|
|
case ADD:
|
2014-04-15 23:16:38 +03:00
|
|
|
require(2)
|
2014-03-21 12:54:36 +02:00
|
|
|
x, y := stack.Popn()
|
2014-06-18 14:48:08 +03:00
|
|
|
vm.Printf(" %v + %v", y, x)
|
|
|
|
|
2014-06-18 01:32:48 +03:00
|
|
|
base.Add(y, x)
|
2014-06-18 14:48:08 +03:00
|
|
|
|
|
|
|
vm.Printf(" = %v", base)
|
2014-03-21 12:54:36 +02:00
|
|
|
// Pop result back on the stack
|
|
|
|
stack.Push(base)
|
2014-05-28 13:05:46 +03:00
|
|
|
case SUB:
|
2014-04-15 23:16:38 +03:00
|
|
|
require(2)
|
2014-03-21 12:54:36 +02:00
|
|
|
x, y := stack.Popn()
|
2014-06-18 14:48:08 +03:00
|
|
|
vm.Printf(" %v - %v", y, x)
|
|
|
|
|
2014-06-18 01:32:48 +03:00
|
|
|
base.Sub(y, x)
|
2014-06-18 14:48:08 +03:00
|
|
|
|
|
|
|
vm.Printf(" = %v", base)
|
2014-03-21 12:54:36 +02:00
|
|
|
// Pop result back on the stack
|
|
|
|
stack.Push(base)
|
2014-05-28 13:05:46 +03:00
|
|
|
case MUL:
|
2014-04-15 23:16:38 +03:00
|
|
|
require(2)
|
2014-03-21 12:54:36 +02:00
|
|
|
x, y := stack.Popn()
|
2014-06-18 14:48:08 +03:00
|
|
|
vm.Printf(" %v * %v", y, x)
|
|
|
|
|
2014-06-18 01:32:48 +03:00
|
|
|
base.Mul(y, x)
|
2014-06-18 14:48:08 +03:00
|
|
|
|
|
|
|
vm.Printf(" = %v", base)
|
2014-03-21 12:54:36 +02:00
|
|
|
// Pop result back on the stack
|
|
|
|
stack.Push(base)
|
2014-05-28 13:05:46 +03:00
|
|
|
case DIV:
|
2014-04-15 23:16:38 +03:00
|
|
|
require(2)
|
2014-03-21 12:54:36 +02:00
|
|
|
x, y := stack.Popn()
|
2014-06-18 14:48:08 +03:00
|
|
|
vm.Printf(" %v / %v", y, x)
|
|
|
|
|
2014-06-18 01:32:48 +03:00
|
|
|
base.Div(y, x)
|
2014-06-18 14:48:08 +03:00
|
|
|
|
|
|
|
vm.Printf(" = %v", base)
|
2014-03-21 12:54:36 +02:00
|
|
|
// Pop result back on the stack
|
|
|
|
stack.Push(base)
|
2014-05-28 13:05:46 +03:00
|
|
|
case SDIV:
|
2014-04-15 23:16:38 +03:00
|
|
|
require(2)
|
2014-03-21 12:54:36 +02:00
|
|
|
x, y := stack.Popn()
|
|
|
|
// n > 2**255
|
|
|
|
if x.Cmp(Pow256) > 0 {
|
|
|
|
x.Sub(Pow256, x)
|
|
|
|
}
|
|
|
|
if y.Cmp(Pow256) > 0 {
|
|
|
|
y.Sub(Pow256, y)
|
|
|
|
}
|
|
|
|
z := new(big.Int)
|
|
|
|
z.Div(x, y)
|
|
|
|
if z.Cmp(Pow256) > 0 {
|
|
|
|
z.Sub(Pow256, z)
|
|
|
|
}
|
|
|
|
// Push result on to the stack
|
|
|
|
stack.Push(z)
|
2014-05-28 13:05:46 +03:00
|
|
|
case MOD:
|
2014-04-15 23:16:38 +03:00
|
|
|
require(2)
|
2014-03-21 12:54:36 +02:00
|
|
|
x, y := stack.Popn()
|
2014-06-18 14:48:08 +03:00
|
|
|
|
|
|
|
vm.Printf(" %v %% %v", y, x)
|
|
|
|
|
2014-06-18 01:32:48 +03:00
|
|
|
base.Mod(y, x)
|
2014-06-18 14:48:08 +03:00
|
|
|
|
|
|
|
vm.Printf(" = %v", base)
|
2014-03-21 12:54:36 +02:00
|
|
|
stack.Push(base)
|
2014-05-28 13:05:46 +03:00
|
|
|
case SMOD:
|
2014-04-15 23:16:38 +03:00
|
|
|
require(2)
|
2014-03-21 12:54:36 +02:00
|
|
|
x, y := stack.Popn()
|
|
|
|
// n > 2**255
|
|
|
|
if x.Cmp(Pow256) > 0 {
|
|
|
|
x.Sub(Pow256, x)
|
|
|
|
}
|
|
|
|
if y.Cmp(Pow256) > 0 {
|
|
|
|
y.Sub(Pow256, y)
|
|
|
|
}
|
|
|
|
z := new(big.Int)
|
|
|
|
z.Mod(x, y)
|
|
|
|
if z.Cmp(Pow256) > 0 {
|
|
|
|
z.Sub(Pow256, z)
|
|
|
|
}
|
|
|
|
// Push result on to the stack
|
|
|
|
stack.Push(z)
|
2014-05-28 13:05:46 +03:00
|
|
|
case EXP:
|
2014-04-15 23:16:38 +03:00
|
|
|
require(2)
|
2014-03-21 12:54:36 +02:00
|
|
|
x, y := stack.Popn()
|
2014-06-18 14:48:08 +03:00
|
|
|
|
|
|
|
vm.Printf(" %v ** %v", y, x)
|
|
|
|
|
2014-06-18 01:32:48 +03:00
|
|
|
base.Exp(y, x, Pow256)
|
2014-03-21 12:54:36 +02:00
|
|
|
|
2014-06-18 14:48:08 +03:00
|
|
|
vm.Printf(" = %v", base)
|
|
|
|
|
2014-03-21 12:54:36 +02:00
|
|
|
stack.Push(base)
|
2014-05-28 13:05:46 +03:00
|
|
|
case NEG:
|
2014-04-15 23:16:38 +03:00
|
|
|
require(1)
|
2014-03-21 12:54:36 +02:00
|
|
|
base.Sub(Pow256, stack.Pop())
|
|
|
|
stack.Push(base)
|
2014-05-28 13:05:46 +03:00
|
|
|
case LT:
|
2014-04-15 23:16:38 +03:00
|
|
|
require(2)
|
2014-06-20 21:11:40 +03:00
|
|
|
x, y := stack.Popn()
|
|
|
|
vm.Printf(" %v < %v", y, x)
|
2014-03-21 12:54:36 +02:00
|
|
|
// x < y
|
2014-06-20 21:11:40 +03:00
|
|
|
if y.Cmp(x) < 0 {
|
2014-03-21 12:54:36 +02:00
|
|
|
stack.Push(ethutil.BigTrue)
|
|
|
|
} else {
|
|
|
|
stack.Push(ethutil.BigFalse)
|
|
|
|
}
|
2014-05-28 13:05:46 +03:00
|
|
|
case GT:
|
2014-04-15 23:16:38 +03:00
|
|
|
require(2)
|
2014-06-20 21:11:40 +03:00
|
|
|
x, y := stack.Popn()
|
|
|
|
vm.Printf(" %v > %v", y, x)
|
2014-06-18 01:25:58 +03:00
|
|
|
|
2014-03-21 12:54:36 +02:00
|
|
|
// x > y
|
2014-06-20 21:11:40 +03:00
|
|
|
if y.Cmp(x) > 0 {
|
2014-03-21 12:54:36 +02:00
|
|
|
stack.Push(ethutil.BigTrue)
|
|
|
|
} else {
|
|
|
|
stack.Push(ethutil.BigFalse)
|
|
|
|
}
|
2014-07-01 12:26:45 +03:00
|
|
|
|
|
|
|
case SLT:
|
|
|
|
require(2)
|
|
|
|
x, y := stack.Popn()
|
|
|
|
vm.Printf(" %v < %v", y, x)
|
|
|
|
// x < y
|
|
|
|
if y.Cmp(x) < 0 {
|
|
|
|
stack.Push(ethutil.BigTrue)
|
|
|
|
} else {
|
|
|
|
stack.Push(ethutil.BigFalse)
|
|
|
|
}
|
|
|
|
case SGT:
|
|
|
|
require(2)
|
|
|
|
x, y := stack.Popn()
|
|
|
|
vm.Printf(" %v > %v", y, x)
|
|
|
|
|
|
|
|
// x > y
|
|
|
|
if y.Cmp(x) > 0 {
|
|
|
|
stack.Push(ethutil.BigTrue)
|
|
|
|
} else {
|
|
|
|
stack.Push(ethutil.BigFalse)
|
|
|
|
}
|
|
|
|
|
2014-05-28 13:05:46 +03:00
|
|
|
case EQ:
|
2014-04-15 23:16:38 +03:00
|
|
|
require(2)
|
2014-03-21 12:54:36 +02:00
|
|
|
x, y := stack.Popn()
|
2014-06-18 01:36:23 +03:00
|
|
|
vm.Printf(" %v == %v", y, x)
|
|
|
|
|
2014-03-30 18:55:51 +02:00
|
|
|
// x == y
|
|
|
|
if x.Cmp(y) == 0 {
|
|
|
|
stack.Push(ethutil.BigTrue)
|
|
|
|
} else {
|
|
|
|
stack.Push(ethutil.BigFalse)
|
|
|
|
}
|
2014-05-28 13:05:46 +03:00
|
|
|
case NOT:
|
2014-04-15 23:16:38 +03:00
|
|
|
require(1)
|
2014-03-30 18:55:51 +02:00
|
|
|
x := stack.Pop()
|
2014-06-23 12:26:51 +03:00
|
|
|
if x.Cmp(ethutil.BigFalse) > 0 {
|
2014-03-21 12:54:36 +02:00
|
|
|
stack.Push(ethutil.BigFalse)
|
2014-06-23 12:26:51 +03:00
|
|
|
} else {
|
|
|
|
stack.Push(ethutil.BigTrue)
|
2014-03-21 12:54:36 +02:00
|
|
|
}
|
|
|
|
|
2014-04-15 23:16:38 +03:00
|
|
|
// 0x10 range
|
2014-05-28 13:05:46 +03:00
|
|
|
case AND:
|
2014-04-15 23:16:38 +03:00
|
|
|
require(2)
|
2014-04-09 15:08:18 +03:00
|
|
|
x, y := stack.Popn()
|
2014-06-18 01:36:23 +03:00
|
|
|
vm.Printf(" %v & %v", y, x)
|
|
|
|
|
2014-06-18 01:32:48 +03:00
|
|
|
stack.Push(base.And(y, x))
|
2014-05-28 13:05:46 +03:00
|
|
|
case OR:
|
2014-04-15 23:16:38 +03:00
|
|
|
require(2)
|
2014-04-09 15:08:18 +03:00
|
|
|
x, y := stack.Popn()
|
2014-06-18 01:36:23 +03:00
|
|
|
vm.Printf(" %v | %v", y, x)
|
|
|
|
|
2014-06-18 01:32:48 +03:00
|
|
|
stack.Push(base.Or(y, x))
|
2014-05-28 13:05:46 +03:00
|
|
|
case XOR:
|
2014-04-15 23:16:38 +03:00
|
|
|
require(2)
|
2014-04-09 15:08:18 +03:00
|
|
|
x, y := stack.Popn()
|
2014-06-18 01:36:23 +03:00
|
|
|
vm.Printf(" %v ^ %v", y, x)
|
|
|
|
|
|
|
|
stack.Push(base.Xor(y, x))
|
2014-05-28 13:05:46 +03:00
|
|
|
case BYTE:
|
2014-04-15 23:16:38 +03:00
|
|
|
require(2)
|
2014-04-09 15:08:18 +03:00
|
|
|
val, th := stack.Popn()
|
|
|
|
if th.Cmp(big.NewInt(32)) < 0 {
|
|
|
|
stack.Push(big.NewInt(int64(len(val.Bytes())-1) - th.Int64()))
|
|
|
|
} else {
|
|
|
|
stack.Push(ethutil.BigFalse)
|
|
|
|
}
|
2014-03-21 12:54:36 +02:00
|
|
|
|
2014-04-15 23:16:38 +03:00
|
|
|
// 0x20 range
|
2014-05-28 13:05:46 +03:00
|
|
|
case SHA3:
|
2014-04-15 23:16:38 +03:00
|
|
|
require(2)
|
2014-04-09 15:08:18 +03:00
|
|
|
size, offset := stack.Popn()
|
2014-06-29 20:30:05 +03:00
|
|
|
data := ethcrypto.Sha3Bin(mem.Get(offset.Int64(), size.Int64()))
|
2014-03-21 12:54:36 +02:00
|
|
|
|
2014-04-09 15:08:18 +03:00
|
|
|
stack.Push(ethutil.BigD(data))
|
2014-04-15 23:16:38 +03:00
|
|
|
// 0x30 range
|
2014-05-28 13:05:46 +03:00
|
|
|
case ADDRESS:
|
2014-03-21 15:47:55 +02:00
|
|
|
stack.Push(ethutil.BigD(closure.Object().Address()))
|
2014-05-28 13:05:46 +03:00
|
|
|
case BALANCE:
|
2014-05-08 15:20:45 +03:00
|
|
|
stack.Push(closure.object.Amount)
|
2014-05-28 13:05:46 +03:00
|
|
|
case ORIGIN:
|
2014-04-11 20:29:57 +03:00
|
|
|
stack.Push(ethutil.BigD(vm.vars.Origin))
|
2014-05-28 13:05:46 +03:00
|
|
|
case CALLER:
|
2014-06-18 01:25:58 +03:00
|
|
|
caller := closure.caller.Address()
|
|
|
|
stack.Push(ethutil.BigD(caller))
|
|
|
|
|
|
|
|
vm.Printf(" => %x", caller)
|
2014-05-28 13:05:46 +03:00
|
|
|
case CALLVALUE:
|
2014-05-07 12:05:49 +03:00
|
|
|
stack.Push(vm.vars.Value)
|
2014-05-28 13:05:46 +03:00
|
|
|
case CALLDATALOAD:
|
2014-04-15 23:16:38 +03:00
|
|
|
require(1)
|
2014-04-23 12:51:04 +03:00
|
|
|
offset := stack.Pop().Int64()
|
|
|
|
|
2014-06-18 14:48:08 +03:00
|
|
|
data := make([]byte, 32)
|
2014-06-17 19:05:46 +03:00
|
|
|
if len(closure.Args) >= int(offset) {
|
|
|
|
l := int64(math.Min(float64(offset+32), float64(len(closure.Args))))
|
2014-06-18 14:48:08 +03:00
|
|
|
|
|
|
|
copy(data, closure.Args[offset:l])
|
2014-05-29 00:16:54 +03:00
|
|
|
}
|
|
|
|
|
2014-06-18 01:25:58 +03:00
|
|
|
vm.Printf(" => 0x%x", data)
|
|
|
|
|
2014-05-29 00:16:54 +03:00
|
|
|
stack.Push(ethutil.BigD(data))
|
2014-05-28 13:05:46 +03:00
|
|
|
case CALLDATASIZE:
|
2014-06-18 01:25:58 +03:00
|
|
|
l := int64(len(closure.Args))
|
|
|
|
stack.Push(big.NewInt(l))
|
|
|
|
|
|
|
|
vm.Printf(" => %d", l)
|
2014-06-12 12:19:32 +03:00
|
|
|
case CALLDATACOPY:
|
2014-06-20 02:10:20 +03:00
|
|
|
var (
|
|
|
|
size = int64(len(closure.Args))
|
|
|
|
mOff = stack.Pop().Int64()
|
|
|
|
cOff = stack.Pop().Int64()
|
|
|
|
l = stack.Pop().Int64()
|
|
|
|
)
|
|
|
|
|
|
|
|
if cOff > size {
|
|
|
|
cOff = 0
|
|
|
|
l = 0
|
|
|
|
} else if cOff+l > size {
|
|
|
|
l = 0
|
|
|
|
}
|
|
|
|
|
|
|
|
code := closure.Args[cOff : cOff+l]
|
|
|
|
|
|
|
|
mem.Set(mOff, l, code)
|
2014-06-12 12:19:32 +03:00
|
|
|
case CODESIZE:
|
2014-06-20 02:10:20 +03:00
|
|
|
l := big.NewInt(int64(len(closure.Script)))
|
|
|
|
stack.Push(l)
|
|
|
|
|
|
|
|
vm.Printf(" => %d", l)
|
2014-06-12 12:19:32 +03:00
|
|
|
case CODECOPY:
|
2014-06-13 13:45:11 +03:00
|
|
|
var (
|
|
|
|
size = int64(len(closure.Script))
|
|
|
|
mOff = stack.Pop().Int64()
|
|
|
|
cOff = stack.Pop().Int64()
|
|
|
|
l = stack.Pop().Int64()
|
|
|
|
)
|
|
|
|
|
|
|
|
if cOff > size {
|
|
|
|
cOff = 0
|
|
|
|
l = 0
|
|
|
|
} else if cOff+l > size {
|
|
|
|
l = 0
|
|
|
|
}
|
|
|
|
|
|
|
|
code := closure.Script[cOff : cOff+l]
|
|
|
|
|
|
|
|
mem.Set(mOff, l, code)
|
2014-05-28 13:05:46 +03:00
|
|
|
case GASPRICE:
|
2014-04-20 02:31:01 +03:00
|
|
|
stack.Push(closure.Price)
|
2014-03-21 12:54:36 +02:00
|
|
|
|
2014-04-15 23:16:38 +03:00
|
|
|
// 0x40 range
|
2014-05-28 13:05:46 +03:00
|
|
|
case PREVHASH:
|
2014-04-11 20:29:57 +03:00
|
|
|
stack.Push(ethutil.BigD(vm.vars.PrevHash))
|
2014-05-28 13:05:46 +03:00
|
|
|
case COINBASE:
|
2014-04-11 20:29:57 +03:00
|
|
|
stack.Push(ethutil.BigD(vm.vars.Coinbase))
|
2014-05-28 13:05:46 +03:00
|
|
|
case TIMESTAMP:
|
2014-04-11 20:29:57 +03:00
|
|
|
stack.Push(big.NewInt(vm.vars.Time))
|
2014-05-28 13:05:46 +03:00
|
|
|
case NUMBER:
|
2014-06-19 14:45:29 +03:00
|
|
|
stack.Push(vm.vars.BlockNumber)
|
2014-05-28 13:05:46 +03:00
|
|
|
case DIFFICULTY:
|
2014-04-11 20:29:57 +03:00
|
|
|
stack.Push(vm.vars.Diff)
|
2014-05-28 13:05:46 +03:00
|
|
|
case GASLIMIT:
|
2014-04-20 02:31:01 +03:00
|
|
|
// TODO
|
|
|
|
stack.Push(big.NewInt(0))
|
2014-03-21 12:54:36 +02:00
|
|
|
|
2014-05-06 18:43:27 +03:00
|
|
|
// 0x50 range
|
2014-05-28 13:05:46 +03:00
|
|
|
case PUSH1, PUSH2, PUSH3, PUSH4, PUSH5, PUSH6, PUSH7, PUSH8, PUSH9, PUSH10, PUSH11, PUSH12, PUSH13, PUSH14, PUSH15, PUSH16, PUSH17, PUSH18, PUSH19, PUSH20, PUSH21, PUSH22, PUSH23, PUSH24, PUSH25, PUSH26, PUSH27, PUSH28, PUSH29, PUSH30, PUSH31, PUSH32:
|
|
|
|
a := big.NewInt(int64(op) - int64(PUSH1) + 1)
|
2014-03-21 19:22:47 +02:00
|
|
|
pc.Add(pc, ethutil.Big1)
|
2014-05-06 18:43:27 +03:00
|
|
|
data := closure.Gets(pc, a)
|
2014-04-10 21:40:12 +03:00
|
|
|
val := ethutil.BigD(data.Bytes())
|
|
|
|
// Push value to stack
|
2014-03-20 18:26:07 +02:00
|
|
|
stack.Push(val)
|
2014-05-06 18:43:27 +03:00
|
|
|
pc.Add(pc, a.Sub(a, big.NewInt(1)))
|
2014-04-11 01:14:19 +03:00
|
|
|
|
2014-05-28 13:05:46 +03:00
|
|
|
step += int(op) - int(PUSH1) + 1
|
2014-06-17 19:49:26 +03:00
|
|
|
|
2014-06-18 01:25:58 +03:00
|
|
|
vm.Printf(" => 0x%x", data.Bytes())
|
2014-05-28 13:05:46 +03:00
|
|
|
case POP:
|
2014-04-15 23:16:38 +03:00
|
|
|
require(1)
|
2014-03-21 15:47:55 +02:00
|
|
|
stack.Pop()
|
2014-05-28 13:05:46 +03:00
|
|
|
case DUP:
|
2014-04-15 23:16:38 +03:00
|
|
|
require(1)
|
2014-03-21 15:47:55 +02:00
|
|
|
stack.Push(stack.Peek())
|
2014-06-20 01:41:28 +03:00
|
|
|
|
|
|
|
vm.Printf(" => 0x%x", stack.Peek().Bytes())
|
2014-05-28 13:05:46 +03:00
|
|
|
case SWAP:
|
2014-04-15 23:16:38 +03:00
|
|
|
require(2)
|
2014-03-21 15:47:55 +02:00
|
|
|
x, y := stack.Popn()
|
|
|
|
stack.Push(y)
|
|
|
|
stack.Push(x)
|
2014-05-28 13:05:46 +03:00
|
|
|
case MLOAD:
|
2014-04-15 23:16:38 +03:00
|
|
|
require(1)
|
2014-03-21 12:54:36 +02:00
|
|
|
offset := stack.Pop()
|
2014-06-20 21:11:40 +03:00
|
|
|
val := ethutil.BigD(mem.Get(offset.Int64(), 32))
|
|
|
|
stack.Push(val)
|
|
|
|
|
|
|
|
vm.Printf(" => 0x%x", val.Bytes())
|
2014-05-28 13:05:46 +03:00
|
|
|
case MSTORE: // Store the value at stack top-1 in to memory at location stack top
|
2014-04-15 23:16:38 +03:00
|
|
|
require(2)
|
2014-03-20 18:26:07 +02:00
|
|
|
// Pop value of the stack
|
2014-03-20 20:50:53 +02:00
|
|
|
val, mStart := stack.Popn()
|
2014-03-20 23:51:20 +02:00
|
|
|
mem.Set(mStart.Int64(), 32, ethutil.BigToBytes(val, 256))
|
2014-06-17 19:49:26 +03:00
|
|
|
|
2014-06-18 01:25:58 +03:00
|
|
|
vm.Printf(" => 0x%x", val)
|
2014-05-28 13:05:46 +03:00
|
|
|
case MSTORE8:
|
2014-04-15 23:16:38 +03:00
|
|
|
require(2)
|
2014-03-21 15:47:55 +02:00
|
|
|
val, mStart := stack.Popn()
|
|
|
|
base.And(val, new(big.Int).SetInt64(0xff))
|
|
|
|
mem.Set(mStart.Int64(), 32, ethutil.BigToBytes(base, 256))
|
2014-06-17 19:49:26 +03:00
|
|
|
|
2014-06-18 01:25:58 +03:00
|
|
|
vm.Printf(" => 0x%x", val)
|
2014-05-28 13:05:46 +03:00
|
|
|
case SLOAD:
|
2014-04-15 23:16:38 +03:00
|
|
|
require(1)
|
2014-03-21 15:47:55 +02:00
|
|
|
loc := stack.Pop()
|
2014-07-02 01:06:21 +03:00
|
|
|
val := closure.GetStorage(loc)
|
2014-06-23 12:26:51 +03:00
|
|
|
|
2014-03-21 15:47:55 +02:00
|
|
|
stack.Push(val.BigInt())
|
2014-06-18 01:25:58 +03:00
|
|
|
|
2014-07-04 16:32:10 +03:00
|
|
|
vm.Printf(" {0x%x : 0x%x}", loc.Bytes(), val.Bytes())
|
2014-05-28 13:05:46 +03:00
|
|
|
case SSTORE:
|
2014-04-15 23:16:38 +03:00
|
|
|
require(2)
|
2014-03-21 19:22:47 +02:00
|
|
|
val, loc := stack.Popn()
|
2014-06-20 21:11:40 +03:00
|
|
|
closure.SetStorage(loc, ethutil.NewValue(val))
|
2014-04-30 15:43:32 +03:00
|
|
|
|
|
|
|
// Add the change to manifest
|
2014-05-08 20:09:36 +03:00
|
|
|
vm.state.manifest.AddStorageChange(closure.Object(), loc.Bytes(), val)
|
2014-06-17 19:49:26 +03:00
|
|
|
|
2014-07-04 16:32:10 +03:00
|
|
|
vm.Printf(" {0x%x : 0x%x}", loc, val)
|
2014-05-28 13:05:46 +03:00
|
|
|
case JUMP:
|
2014-04-15 23:16:38 +03:00
|
|
|
require(1)
|
2014-03-21 19:22:47 +02:00
|
|
|
pc = stack.Pop()
|
2014-04-20 02:31:01 +03:00
|
|
|
// Reduce pc by one because of the increment that's at the end of this for loop
|
2014-06-17 19:49:26 +03:00
|
|
|
vm.Printf(" ~> %v", pc).Endl()
|
|
|
|
|
2014-05-08 15:20:45 +03:00
|
|
|
continue
|
2014-05-28 13:05:46 +03:00
|
|
|
case JUMPI:
|
2014-04-15 23:16:38 +03:00
|
|
|
require(2)
|
2014-03-30 18:55:51 +02:00
|
|
|
cond, pos := stack.Popn()
|
2014-06-17 19:05:46 +03:00
|
|
|
if cond.Cmp(ethutil.BigTrue) >= 0 {
|
2014-03-21 19:22:47 +02:00
|
|
|
pc = pos
|
2014-06-17 19:49:26 +03:00
|
|
|
|
2014-06-18 14:48:08 +03:00
|
|
|
vm.Printf(" ~> %v (t)", pc).Endl()
|
2014-06-17 19:49:26 +03:00
|
|
|
|
2014-05-08 15:20:45 +03:00
|
|
|
continue
|
2014-06-18 01:25:58 +03:00
|
|
|
} else {
|
|
|
|
vm.Printf(" (f)")
|
2014-03-21 19:22:47 +02:00
|
|
|
}
|
2014-05-28 13:05:46 +03:00
|
|
|
case PC:
|
2014-03-21 19:22:47 +02:00
|
|
|
stack.Push(pc)
|
2014-05-28 13:05:46 +03:00
|
|
|
case MSIZE:
|
2014-03-21 19:22:47 +02:00
|
|
|
stack.Push(big.NewInt(int64(mem.Len())))
|
2014-06-12 12:19:32 +03:00
|
|
|
case GAS:
|
|
|
|
stack.Push(closure.Gas)
|
2014-04-15 23:16:38 +03:00
|
|
|
// 0x60 range
|
2014-05-28 13:05:46 +03:00
|
|
|
case CREATE:
|
2014-04-27 17:50:44 +03:00
|
|
|
require(3)
|
|
|
|
|
2014-07-02 18:47:09 +03:00
|
|
|
var (
|
|
|
|
err error
|
|
|
|
value = stack.Pop()
|
|
|
|
size, offset = stack.Popn()
|
2014-04-27 17:50:44 +03:00
|
|
|
|
2014-07-02 18:47:09 +03:00
|
|
|
// Snapshot the current stack so we are able to
|
|
|
|
// revert back to it later.
|
|
|
|
snapshot = vm.state.Copy()
|
|
|
|
)
|
2014-05-26 01:09:38 +03:00
|
|
|
|
2014-04-27 17:50:44 +03:00
|
|
|
// Generate a new address
|
2014-07-03 11:04:38 +03:00
|
|
|
addr := ethcrypto.CreateAddress(closure.object.Address(), closure.object.Nonce)
|
|
|
|
for i := uint64(0); vm.state.GetStateObject(addr) != nil; i++ {
|
|
|
|
ethcrypto.CreateAddress(closure.object.Address(), closure.object.Nonce+i)
|
2014-07-02 18:47:09 +03:00
|
|
|
}
|
2014-07-03 11:04:38 +03:00
|
|
|
closure.object.Nonce++
|
2014-06-23 17:11:55 +03:00
|
|
|
|
|
|
|
vm.Printf(" (*) %x", addr).Endl()
|
|
|
|
|
2014-04-27 17:50:44 +03:00
|
|
|
// Create a new contract
|
2014-06-23 14:42:30 +03:00
|
|
|
contract := vm.state.NewStateObject(addr)
|
2014-07-02 18:47:09 +03:00
|
|
|
if contract.Amount.Cmp(value) >= 0 {
|
|
|
|
closure.object.SubAmount(value)
|
|
|
|
contract.AddAmount(value)
|
|
|
|
|
|
|
|
// Set the init script
|
2014-07-03 11:04:38 +03:00
|
|
|
contract.initScript = mem.Get(offset.Int64(), size.Int64())
|
2014-07-02 18:47:09 +03:00
|
|
|
// Transfer all remaining gas to the new
|
|
|
|
// contract so it may run the init script
|
|
|
|
gas := new(big.Int).Set(closure.Gas)
|
|
|
|
closure.UseGas(closure.Gas)
|
|
|
|
|
|
|
|
// Create the closure
|
|
|
|
c := NewClosure(closure, contract, contract.initScript, vm.state, gas, closure.Price)
|
|
|
|
// Call the closure and set the return value as
|
|
|
|
// main script.
|
2014-07-03 17:07:21 +03:00
|
|
|
contract.script, err = Call(vm, c, nil)
|
2014-07-02 18:47:09 +03:00
|
|
|
} else {
|
|
|
|
err = fmt.Errorf("Insufficient funds to transfer value. Req %v, has %v", value, closure.object.Amount)
|
|
|
|
}
|
2014-05-28 13:05:46 +03:00
|
|
|
|
2014-04-27 17:50:44 +03:00
|
|
|
if err != nil {
|
|
|
|
stack.Push(ethutil.BigFalse)
|
2014-05-26 01:09:38 +03:00
|
|
|
|
|
|
|
// Revert the state as it was before.
|
2014-06-20 01:41:28 +03:00
|
|
|
vm.state.Set(snapshot)
|
2014-07-02 18:47:09 +03:00
|
|
|
|
|
|
|
vm.Printf("CREATE err %v", err)
|
2014-04-27 17:50:44 +03:00
|
|
|
} else {
|
|
|
|
stack.Push(ethutil.BigD(addr))
|
2014-07-02 18:47:09 +03:00
|
|
|
vm.Printf("CREATE success")
|
2014-04-27 17:50:44 +03:00
|
|
|
}
|
2014-07-02 18:47:09 +03:00
|
|
|
vm.Endl()
|
2014-05-28 13:05:46 +03:00
|
|
|
case CALL:
|
2014-04-18 14:41:07 +03:00
|
|
|
require(7)
|
2014-06-19 14:45:29 +03:00
|
|
|
|
|
|
|
vm.Endl()
|
|
|
|
|
|
|
|
gas := stack.Pop()
|
2014-04-10 21:40:12 +03:00
|
|
|
// Pop gas and value of the stack.
|
2014-06-19 14:45:29 +03:00
|
|
|
value, addr := stack.Popn()
|
2014-03-20 18:26:07 +02:00
|
|
|
// Pop input size and offset
|
|
|
|
inSize, inOffset := stack.Popn()
|
2014-04-10 21:40:12 +03:00
|
|
|
// Pop return size and offset
|
|
|
|
retSize, retOffset := stack.Popn()
|
2014-05-08 15:20:45 +03:00
|
|
|
|
2014-03-21 12:54:36 +02:00
|
|
|
// Get the arguments from the memory
|
|
|
|
args := mem.Get(inOffset.Int64(), inSize.Int64())
|
2014-05-08 15:20:45 +03:00
|
|
|
|
2014-06-16 12:14:01 +03:00
|
|
|
if closure.object.Amount.Cmp(value) < 0 {
|
2014-06-23 14:54:10 +03:00
|
|
|
vmlogger.Debugf("Insufficient funds to transfer value. Req %v, has %v", value, closure.object.Amount)
|
2014-05-08 15:20:45 +03:00
|
|
|
|
2014-06-16 12:14:01 +03:00
|
|
|
stack.Push(ethutil.BigFalse)
|
|
|
|
} else {
|
2014-07-03 17:07:21 +03:00
|
|
|
//snapshot := vm.state.Copy()
|
2014-06-20 01:41:28 +03:00
|
|
|
|
2014-06-19 14:45:29 +03:00
|
|
|
stateObject := vm.state.GetOrNewStateObject(addr.Bytes())
|
|
|
|
|
|
|
|
closure.object.SubAmount(value)
|
|
|
|
stateObject.AddAmount(value)
|
|
|
|
|
|
|
|
// Create a new callable closure
|
2014-07-04 01:12:21 +03:00
|
|
|
c := NewClosure(closure, stateObject, stateObject.script, vm.state, gas, closure.Price)
|
2014-06-19 14:45:29 +03:00
|
|
|
// Executer the closure and get the return value (if any)
|
2014-07-04 01:12:21 +03:00
|
|
|
ret, err := Call(vm, c, args)
|
2014-06-19 14:45:29 +03:00
|
|
|
if err != nil {
|
2014-06-16 12:14:01 +03:00
|
|
|
stack.Push(ethutil.BigFalse)
|
2014-06-19 14:45:29 +03:00
|
|
|
|
2014-06-23 14:54:10 +03:00
|
|
|
vmlogger.Debugf("Closure execution failed. %v\n", err)
|
2014-06-20 01:41:28 +03:00
|
|
|
|
2014-07-03 17:07:21 +03:00
|
|
|
//vm.state.Set(snapshot)
|
|
|
|
vm.state.ResetStateObject(stateObject)
|
2014-06-19 14:45:29 +03:00
|
|
|
} else {
|
|
|
|
stack.Push(ethutil.BigTrue)
|
|
|
|
|
|
|
|
mem.Set(retOffset.Int64(), retSize.Int64(), ret)
|
2014-05-26 01:09:38 +03:00
|
|
|
}
|
2014-04-15 23:16:38 +03:00
|
|
|
}
|
2014-05-28 13:05:46 +03:00
|
|
|
case RETURN:
|
2014-04-15 23:16:38 +03:00
|
|
|
require(2)
|
2014-03-20 18:26:07 +02:00
|
|
|
size, offset := stack.Popn()
|
2014-03-20 23:51:20 +02:00
|
|
|
ret := mem.Get(offset.Int64(), size.Int64())
|
2014-03-20 18:26:07 +02:00
|
|
|
|
2014-06-20 01:41:28 +03:00
|
|
|
vm.Printf(" => (%d) 0x%x", len(ret), ret).Endl()
|
2014-06-19 14:45:29 +03:00
|
|
|
|
2014-04-15 23:16:38 +03:00
|
|
|
return closure.Return(ret), nil
|
2014-05-28 13:05:46 +03:00
|
|
|
case SUICIDE:
|
2014-05-01 23:14:34 +03:00
|
|
|
require(1)
|
|
|
|
|
|
|
|
receiver := vm.state.GetAccount(stack.Pop().Bytes())
|
|
|
|
receiver.AddAmount(closure.object.Amount)
|
|
|
|
|
2014-07-02 01:06:21 +03:00
|
|
|
closure.object.MarkForDeletion()
|
|
|
|
|
|
|
|
/*
|
|
|
|
trie := closure.object.state.trie
|
|
|
|
trie.NewIterator().Each(func(key string, v *ethutil.Value) {
|
|
|
|
trie.Delete(key)
|
|
|
|
})
|
|
|
|
*/
|
2014-05-01 23:14:34 +03:00
|
|
|
|
|
|
|
fallthrough
|
2014-05-28 13:05:46 +03:00
|
|
|
case STOP: // Stop the closure
|
2014-06-23 12:26:51 +03:00
|
|
|
vm.Endl()
|
2014-06-19 14:45:29 +03:00
|
|
|
|
2014-05-01 23:14:34 +03:00
|
|
|
return closure.Return(nil), nil
|
2014-03-21 12:54:36 +02:00
|
|
|
default:
|
2014-07-01 12:26:45 +03:00
|
|
|
vmlogger.Debugf("(pc) %-3v Invalid opcode %x\n", pc, op)
|
|
|
|
fmt.Println(Code(closure.Script))
|
2014-04-10 21:40:12 +03:00
|
|
|
|
2014-04-15 23:16:38 +03:00
|
|
|
return closure.Return(nil), fmt.Errorf("Invalid opcode %x", op)
|
2014-03-20 18:26:07 +02:00
|
|
|
}
|
|
|
|
|
2014-03-21 19:22:47 +02:00
|
|
|
pc.Add(pc, ethutil.Big1)
|
2014-02-24 13:10:45 +02:00
|
|
|
|
2014-06-17 19:49:26 +03:00
|
|
|
vm.Endl()
|
|
|
|
|
2014-07-02 02:04:21 +03:00
|
|
|
if vm.Hook != nil {
|
2014-07-02 14:08:32 +03:00
|
|
|
for _, instrNo := range vm.BreakPoints {
|
|
|
|
if pc.Cmp(big.NewInt(instrNo)) == 0 || vm.Stepping {
|
|
|
|
vm.Stepping = true
|
|
|
|
|
|
|
|
if !vm.Hook(prevStep, op, mem, stack, closure.Object()) {
|
|
|
|
return nil, nil
|
|
|
|
}
|
|
|
|
}
|
2014-05-27 14:32:31 +03:00
|
|
|
}
|
2014-04-11 20:29:57 +03:00
|
|
|
}
|
2014-07-02 14:08:32 +03:00
|
|
|
|
2014-04-11 20:29:57 +03:00
|
|
|
}
|
|
|
|
}
|