|
|
@ -7,16 +7,13 @@ import ( |
|
|
|
"github.com/ethereum/go-ethereum/common" |
|
|
|
"github.com/ethereum/go-ethereum/common" |
|
|
|
"github.com/ethereum/go-ethereum/core/state" |
|
|
|
"github.com/ethereum/go-ethereum/core/state" |
|
|
|
"github.com/ethereum/go-ethereum/crypto" |
|
|
|
"github.com/ethereum/go-ethereum/crypto" |
|
|
|
"github.com/ethereum/go-ethereum/logger/glog" |
|
|
|
|
|
|
|
"github.com/ethereum/go-ethereum/params" |
|
|
|
"github.com/ethereum/go-ethereum/params" |
|
|
|
) |
|
|
|
) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Vm implements VirtualMachine
|
|
|
|
type Vm struct { |
|
|
|
type Vm struct { |
|
|
|
env Environment |
|
|
|
env Environment |
|
|
|
|
|
|
|
|
|
|
|
logTy byte |
|
|
|
|
|
|
|
logStr string |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
err error |
|
|
|
err error |
|
|
|
// For logging
|
|
|
|
// For logging
|
|
|
|
debug bool |
|
|
|
debug bool |
|
|
@ -31,13 +28,13 @@ type Vm struct { |
|
|
|
After func(*Context, error) |
|
|
|
After func(*Context, error) |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// New returns a new Virtual Machine
|
|
|
|
func New(env Environment) *Vm { |
|
|
|
func New(env Environment) *Vm { |
|
|
|
lt := LogTyPretty |
|
|
|
return &Vm{env: env, debug: Debug, Recoverable: true} |
|
|
|
|
|
|
|
|
|
|
|
return &Vm{debug: Debug, env: env, logTy: lt, Recoverable: true} |
|
|
|
|
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) { |
|
|
|
// Run loops and evaluates the contract's code with the given input data
|
|
|
|
|
|
|
|
func (self *Vm) Run(context *Context, input []byte) (ret []byte, err error) { |
|
|
|
self.env.SetDepth(self.env.Depth() + 1) |
|
|
|
self.env.SetDepth(self.env.Depth() + 1) |
|
|
|
defer self.env.SetDepth(self.env.Depth() - 1) |
|
|
|
defer self.env.SetDepth(self.env.Depth() - 1) |
|
|
|
|
|
|
|
|
|
|
@ -48,8 +45,6 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) { |
|
|
|
price = context.Price |
|
|
|
price = context.Price |
|
|
|
) |
|
|
|
) |
|
|
|
|
|
|
|
|
|
|
|
self.Printf("(%d) (%x) %x (code=%d) gas: %v (d) %x", self.env.Depth(), caller.Address().Bytes()[:4], context.Address(), len(code), context.Gas, callData).Endl() |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// User defer pattern to check for an error and, based on the error being nil or not, use all gas and return.
|
|
|
|
// User defer pattern to check for an error and, based on the error being nil or not, use all gas and return.
|
|
|
|
defer func() { |
|
|
|
defer func() { |
|
|
|
if self.After != nil { |
|
|
|
if self.After != nil { |
|
|
@ -57,7 +52,7 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) { |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
if err != nil { |
|
|
|
if err != nil { |
|
|
|
self.Printf(" %v", err).Endl() |
|
|
|
|
|
|
|
// In case of a VM exception (known exceptions) all gas consumed (panics NOT included).
|
|
|
|
// In case of a VM exception (known exceptions) all gas consumed (panics NOT included).
|
|
|
|
context.UseGas(context.Gas) |
|
|
|
context.UseGas(context.Gas) |
|
|
|
|
|
|
|
|
|
|
@ -67,7 +62,7 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) { |
|
|
|
|
|
|
|
|
|
|
|
if context.CodeAddr != nil { |
|
|
|
if context.CodeAddr != nil { |
|
|
|
if p := Precompiled[context.CodeAddr.Str()]; p != nil { |
|
|
|
if p := Precompiled[context.CodeAddr.Str()]; p != nil { |
|
|
|
return self.RunPrecompiled(p, callData, context) |
|
|
|
return self.RunPrecompiled(p, input, context) |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
@ -77,23 +72,24 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) { |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
var ( |
|
|
|
var ( |
|
|
|
op OpCode |
|
|
|
op OpCode // current opcode
|
|
|
|
codehash = crypto.Sha3Hash(code) |
|
|
|
codehash = crypto.Sha3Hash(code) // codehash is used when doing jump dest caching
|
|
|
|
mem = NewMemory() |
|
|
|
mem = NewMemory() // bound memory
|
|
|
|
stack = newStack() |
|
|
|
stack = newstack() // local stack
|
|
|
|
pc = new(big.Int) |
|
|
|
statedb = self.env.State() // current state
|
|
|
|
statedb = self.env.State() |
|
|
|
// For optimisation reason we're using uint64 as the program counter.
|
|
|
|
|
|
|
|
// It's theoretically possible to go above 2^64. The YP defines the PC to be uint256. Pratically much less so feasible.
|
|
|
|
jump = func(from *big.Int, to *big.Int) error { |
|
|
|
pc = uint64(0) // program counter
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// jump evaluates and checks whether the given jump destination is a valid one
|
|
|
|
|
|
|
|
// if valid move the `pc` otherwise return an error.
|
|
|
|
|
|
|
|
jump = func(from uint64, to *big.Int) error { |
|
|
|
if !context.jumpdests.has(codehash, code, to) { |
|
|
|
if !context.jumpdests.has(codehash, code, to) { |
|
|
|
nop := context.GetOp(to) |
|
|
|
nop := context.GetOp(to.Uint64()) |
|
|
|
return fmt.Errorf("invalid jump destination (%v) %v", nop, to) |
|
|
|
return fmt.Errorf("invalid jump destination (%v) %v", nop, to) |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
self.Printf(" ~> %v", to) |
|
|
|
pc = to.Uint64() |
|
|
|
pc = to |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
self.Endl() |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
return nil |
|
|
|
return nil |
|
|
|
} |
|
|
|
} |
|
|
@ -106,63 +102,56 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) { |
|
|
|
// Get the memory location of pc
|
|
|
|
// Get the memory location of pc
|
|
|
|
op = context.GetOp(pc) |
|
|
|
op = context.GetOp(pc) |
|
|
|
|
|
|
|
|
|
|
|
self.Printf("(pc) %-3d -o- %-14s (m) %-4d (s) %-4d ", pc, op.String(), mem.Len(), stack.len()) |
|
|
|
// calculate the new memory size and gas price for the current executing opcode
|
|
|
|
newMemSize, gas, err := self.calculateGasAndSize(context, caller, op, statedb, mem, stack) |
|
|
|
newMemSize, gas, err := self.calculateGasAndSize(context, caller, op, statedb, mem, stack) |
|
|
|
if err != nil { |
|
|
|
if err != nil { |
|
|
|
return nil, err |
|
|
|
return nil, err |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
self.Printf("(g) %-3v (%v)", gas, context.Gas) |
|
|
|
self.log(pc, op, context.Gas, gas, mem, stack, context) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Use the calculated gas. When insufficient gas is present, use all gas and return an
|
|
|
|
|
|
|
|
// Out Of Gas error
|
|
|
|
if !context.UseGas(gas) { |
|
|
|
if !context.UseGas(gas) { |
|
|
|
self.Endl() |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
tmp := new(big.Int).Set(context.Gas) |
|
|
|
tmp := new(big.Int).Set(context.Gas) |
|
|
|
|
|
|
|
|
|
|
|
context.UseGas(context.Gas) |
|
|
|
context.UseGas(context.Gas) |
|
|
|
|
|
|
|
|
|
|
|
return context.Return(nil), OOG(gas, tmp) |
|
|
|
return context.Return(nil), OOG(gas, tmp) |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
// Resize the memory calculated previously
|
|
|
|
mem.Resize(newMemSize.Uint64()) |
|
|
|
mem.Resize(newMemSize.Uint64()) |
|
|
|
|
|
|
|
|
|
|
|
switch op { |
|
|
|
switch op { |
|
|
|
case ADD: |
|
|
|
case ADD: |
|
|
|
x, y := stack.pop(), stack.pop() |
|
|
|
x, y := stack.pop(), stack.pop() |
|
|
|
self.Printf(" %v + %v", y, x) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
base.Add(x, y) |
|
|
|
base.Add(x, y) |
|
|
|
|
|
|
|
|
|
|
|
U256(base) |
|
|
|
U256(base) |
|
|
|
|
|
|
|
|
|
|
|
self.Printf(" = %v", base) |
|
|
|
|
|
|
|
// pop result back on the stack
|
|
|
|
// pop result back on the stack
|
|
|
|
stack.push(base) |
|
|
|
stack.push(base) |
|
|
|
case SUB: |
|
|
|
case SUB: |
|
|
|
x, y := stack.pop(), stack.pop() |
|
|
|
x, y := stack.pop(), stack.pop() |
|
|
|
self.Printf(" %v - %v", x, y) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
base.Sub(x, y) |
|
|
|
base.Sub(x, y) |
|
|
|
|
|
|
|
|
|
|
|
U256(base) |
|
|
|
U256(base) |
|
|
|
|
|
|
|
|
|
|
|
self.Printf(" = %v", base) |
|
|
|
|
|
|
|
// pop result back on the stack
|
|
|
|
// pop result back on the stack
|
|
|
|
stack.push(base) |
|
|
|
stack.push(base) |
|
|
|
case MUL: |
|
|
|
case MUL: |
|
|
|
x, y := stack.pop(), stack.pop() |
|
|
|
x, y := stack.pop(), stack.pop() |
|
|
|
self.Printf(" %v * %v", y, x) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
base.Mul(x, y) |
|
|
|
base.Mul(x, y) |
|
|
|
|
|
|
|
|
|
|
|
U256(base) |
|
|
|
U256(base) |
|
|
|
|
|
|
|
|
|
|
|
self.Printf(" = %v", base) |
|
|
|
|
|
|
|
// pop result back on the stack
|
|
|
|
// pop result back on the stack
|
|
|
|
stack.push(base) |
|
|
|
stack.push(base) |
|
|
|
case DIV: |
|
|
|
case DIV: |
|
|
|
x, y := stack.pop(), stack.pop() |
|
|
|
x, y := stack.pop(), stack.pop() |
|
|
|
self.Printf(" %v / %v", x, y) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if y.Cmp(common.Big0) != 0 { |
|
|
|
if y.Cmp(common.Big0) != 0 { |
|
|
|
base.Div(x, y) |
|
|
|
base.Div(x, y) |
|
|
@ -170,14 +159,11 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) { |
|
|
|
|
|
|
|
|
|
|
|
U256(base) |
|
|
|
U256(base) |
|
|
|
|
|
|
|
|
|
|
|
self.Printf(" = %v", base) |
|
|
|
|
|
|
|
// pop result back on the stack
|
|
|
|
// pop result back on the stack
|
|
|
|
stack.push(base) |
|
|
|
stack.push(base) |
|
|
|
case SDIV: |
|
|
|
case SDIV: |
|
|
|
x, y := S256(stack.pop()), S256(stack.pop()) |
|
|
|
x, y := S256(stack.pop()), S256(stack.pop()) |
|
|
|
|
|
|
|
|
|
|
|
self.Printf(" %v / %v", x, y) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if y.Cmp(common.Big0) == 0 { |
|
|
|
if y.Cmp(common.Big0) == 0 { |
|
|
|
base.Set(common.Big0) |
|
|
|
base.Set(common.Big0) |
|
|
|
} else { |
|
|
|
} else { |
|
|
@ -193,13 +179,10 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) { |
|
|
|
U256(base) |
|
|
|
U256(base) |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
self.Printf(" = %v", base) |
|
|
|
|
|
|
|
stack.push(base) |
|
|
|
stack.push(base) |
|
|
|
case MOD: |
|
|
|
case MOD: |
|
|
|
x, y := stack.pop(), stack.pop() |
|
|
|
x, y := stack.pop(), stack.pop() |
|
|
|
|
|
|
|
|
|
|
|
self.Printf(" %v %% %v", x, y) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if y.Cmp(common.Big0) == 0 { |
|
|
|
if y.Cmp(common.Big0) == 0 { |
|
|
|
base.Set(common.Big0) |
|
|
|
base.Set(common.Big0) |
|
|
|
} else { |
|
|
|
} else { |
|
|
@ -208,13 +191,10 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) { |
|
|
|
|
|
|
|
|
|
|
|
U256(base) |
|
|
|
U256(base) |
|
|
|
|
|
|
|
|
|
|
|
self.Printf(" = %v", base) |
|
|
|
|
|
|
|
stack.push(base) |
|
|
|
stack.push(base) |
|
|
|
case SMOD: |
|
|
|
case SMOD: |
|
|
|
x, y := S256(stack.pop()), S256(stack.pop()) |
|
|
|
x, y := S256(stack.pop()), S256(stack.pop()) |
|
|
|
|
|
|
|
|
|
|
|
self.Printf(" %v %% %v", x, y) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if y.Cmp(common.Big0) == 0 { |
|
|
|
if y.Cmp(common.Big0) == 0 { |
|
|
|
base.Set(common.Big0) |
|
|
|
base.Set(common.Big0) |
|
|
|
} else { |
|
|
|
} else { |
|
|
@ -230,20 +210,15 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) { |
|
|
|
U256(base) |
|
|
|
U256(base) |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
self.Printf(" = %v", base) |
|
|
|
|
|
|
|
stack.push(base) |
|
|
|
stack.push(base) |
|
|
|
|
|
|
|
|
|
|
|
case EXP: |
|
|
|
case EXP: |
|
|
|
x, y := stack.pop(), stack.pop() |
|
|
|
x, y := stack.pop(), stack.pop() |
|
|
|
|
|
|
|
|
|
|
|
self.Printf(" %v ** %v", x, y) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
base.Exp(x, y, Pow256) |
|
|
|
base.Exp(x, y, Pow256) |
|
|
|
|
|
|
|
|
|
|
|
U256(base) |
|
|
|
U256(base) |
|
|
|
|
|
|
|
|
|
|
|
self.Printf(" = %v", base) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
stack.push(base) |
|
|
|
stack.push(base) |
|
|
|
case SIGNEXTEND: |
|
|
|
case SIGNEXTEND: |
|
|
|
back := stack.pop() |
|
|
|
back := stack.pop() |
|
|
@ -260,15 +235,13 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) { |
|
|
|
|
|
|
|
|
|
|
|
num = U256(num) |
|
|
|
num = U256(num) |
|
|
|
|
|
|
|
|
|
|
|
self.Printf(" = %v", num) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
stack.push(num) |
|
|
|
stack.push(num) |
|
|
|
} |
|
|
|
} |
|
|
|
case NOT: |
|
|
|
case NOT: |
|
|
|
stack.push(U256(new(big.Int).Not(stack.pop()))) |
|
|
|
stack.push(U256(new(big.Int).Not(stack.pop()))) |
|
|
|
case LT: |
|
|
|
case LT: |
|
|
|
x, y := stack.pop(), stack.pop() |
|
|
|
x, y := stack.pop(), stack.pop() |
|
|
|
self.Printf(" %v < %v", x, y) |
|
|
|
|
|
|
|
// x < y
|
|
|
|
// x < y
|
|
|
|
if x.Cmp(y) < 0 { |
|
|
|
if x.Cmp(y) < 0 { |
|
|
|
stack.push(common.BigTrue) |
|
|
|
stack.push(common.BigTrue) |
|
|
@ -277,7 +250,6 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) { |
|
|
|
} |
|
|
|
} |
|
|
|
case GT: |
|
|
|
case GT: |
|
|
|
x, y := stack.pop(), stack.pop() |
|
|
|
x, y := stack.pop(), stack.pop() |
|
|
|
self.Printf(" %v > %v", x, y) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// x > y
|
|
|
|
// x > y
|
|
|
|
if x.Cmp(y) > 0 { |
|
|
|
if x.Cmp(y) > 0 { |
|
|
@ -288,7 +260,7 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) { |
|
|
|
|
|
|
|
|
|
|
|
case SLT: |
|
|
|
case SLT: |
|
|
|
x, y := S256(stack.pop()), S256(stack.pop()) |
|
|
|
x, y := S256(stack.pop()), S256(stack.pop()) |
|
|
|
self.Printf(" %v < %v", x, y) |
|
|
|
|
|
|
|
// x < y
|
|
|
|
// x < y
|
|
|
|
if x.Cmp(S256(y)) < 0 { |
|
|
|
if x.Cmp(S256(y)) < 0 { |
|
|
|
stack.push(common.BigTrue) |
|
|
|
stack.push(common.BigTrue) |
|
|
@ -297,7 +269,6 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) { |
|
|
|
} |
|
|
|
} |
|
|
|
case SGT: |
|
|
|
case SGT: |
|
|
|
x, y := S256(stack.pop()), S256(stack.pop()) |
|
|
|
x, y := S256(stack.pop()), S256(stack.pop()) |
|
|
|
self.Printf(" %v > %v", x, y) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// x > y
|
|
|
|
// x > y
|
|
|
|
if x.Cmp(y) > 0 { |
|
|
|
if x.Cmp(y) > 0 { |
|
|
@ -308,7 +279,6 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) { |
|
|
|
|
|
|
|
|
|
|
|
case EQ: |
|
|
|
case EQ: |
|
|
|
x, y := stack.pop(), stack.pop() |
|
|
|
x, y := stack.pop(), stack.pop() |
|
|
|
self.Printf(" %v == %v", y, x) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// x == y
|
|
|
|
// x == y
|
|
|
|
if x.Cmp(y) == 0 { |
|
|
|
if x.Cmp(y) == 0 { |
|
|
@ -326,17 +296,14 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) { |
|
|
|
|
|
|
|
|
|
|
|
case AND: |
|
|
|
case AND: |
|
|
|
x, y := stack.pop(), stack.pop() |
|
|
|
x, y := stack.pop(), stack.pop() |
|
|
|
self.Printf(" %v & %v", y, x) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
stack.push(base.And(x, y)) |
|
|
|
stack.push(base.And(x, y)) |
|
|
|
case OR: |
|
|
|
case OR: |
|
|
|
x, y := stack.pop(), stack.pop() |
|
|
|
x, y := stack.pop(), stack.pop() |
|
|
|
self.Printf(" %v | %v", x, y) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
stack.push(base.Or(x, y)) |
|
|
|
stack.push(base.Or(x, y)) |
|
|
|
case XOR: |
|
|
|
case XOR: |
|
|
|
x, y := stack.pop(), stack.pop() |
|
|
|
x, y := stack.pop(), stack.pop() |
|
|
|
self.Printf(" %v ^ %v", x, y) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
stack.push(base.Xor(x, y)) |
|
|
|
stack.push(base.Xor(x, y)) |
|
|
|
case BYTE: |
|
|
|
case BYTE: |
|
|
@ -350,8 +317,6 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) { |
|
|
|
base.Set(common.BigFalse) |
|
|
|
base.Set(common.BigFalse) |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
self.Printf(" => 0x%x", base.Bytes()) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
stack.push(base) |
|
|
|
stack.push(base) |
|
|
|
case ADDMOD: |
|
|
|
case ADDMOD: |
|
|
|
x := stack.pop() |
|
|
|
x := stack.pop() |
|
|
@ -365,8 +330,6 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) { |
|
|
|
base = U256(base) |
|
|
|
base = U256(base) |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
self.Printf(" %v + %v %% %v = %v", x, y, z, base) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
stack.push(base) |
|
|
|
stack.push(base) |
|
|
|
case MULMOD: |
|
|
|
case MULMOD: |
|
|
|
x := stack.pop() |
|
|
|
x := stack.pop() |
|
|
@ -380,8 +343,6 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) { |
|
|
|
U256(base) |
|
|
|
U256(base) |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
self.Printf(" %v + %v %% %v = %v", x, y, z, base) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
stack.push(base) |
|
|
|
stack.push(base) |
|
|
|
|
|
|
|
|
|
|
|
case SHA3: |
|
|
|
case SHA3: |
|
|
@ -390,55 +351,45 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) { |
|
|
|
|
|
|
|
|
|
|
|
stack.push(common.BigD(data)) |
|
|
|
stack.push(common.BigD(data)) |
|
|
|
|
|
|
|
|
|
|
|
self.Printf(" => (%v) %x", size, data) |
|
|
|
|
|
|
|
case ADDRESS: |
|
|
|
case ADDRESS: |
|
|
|
stack.push(common.Bytes2Big(context.Address().Bytes())) |
|
|
|
stack.push(common.Bytes2Big(context.Address().Bytes())) |
|
|
|
|
|
|
|
|
|
|
|
self.Printf(" => %x", context.Address()) |
|
|
|
|
|
|
|
case BALANCE: |
|
|
|
case BALANCE: |
|
|
|
addr := common.BigToAddress(stack.pop()) |
|
|
|
addr := common.BigToAddress(stack.pop()) |
|
|
|
balance := statedb.GetBalance(addr) |
|
|
|
balance := statedb.GetBalance(addr) |
|
|
|
|
|
|
|
|
|
|
|
stack.push(balance) |
|
|
|
stack.push(balance) |
|
|
|
|
|
|
|
|
|
|
|
self.Printf(" => %v (%x)", balance, addr) |
|
|
|
|
|
|
|
case ORIGIN: |
|
|
|
case ORIGIN: |
|
|
|
origin := self.env.Origin() |
|
|
|
origin := self.env.Origin() |
|
|
|
|
|
|
|
|
|
|
|
stack.push(origin.Big()) |
|
|
|
stack.push(origin.Big()) |
|
|
|
|
|
|
|
|
|
|
|
self.Printf(" => %x", origin) |
|
|
|
|
|
|
|
case CALLER: |
|
|
|
case CALLER: |
|
|
|
caller := context.caller.Address() |
|
|
|
caller := context.caller.Address() |
|
|
|
stack.push(common.Bytes2Big(caller.Bytes())) |
|
|
|
stack.push(common.Bytes2Big(caller.Bytes())) |
|
|
|
|
|
|
|
|
|
|
|
self.Printf(" => %x", caller) |
|
|
|
|
|
|
|
case CALLVALUE: |
|
|
|
case CALLVALUE: |
|
|
|
stack.push(value) |
|
|
|
stack.push(value) |
|
|
|
|
|
|
|
|
|
|
|
self.Printf(" => %v", value) |
|
|
|
|
|
|
|
case CALLDATALOAD: |
|
|
|
case CALLDATALOAD: |
|
|
|
data := getData(callData, stack.pop(), common.Big32) |
|
|
|
data := getData(input, stack.pop(), common.Big32) |
|
|
|
|
|
|
|
|
|
|
|
self.Printf(" => 0x%x", data) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
stack.push(common.Bytes2Big(data)) |
|
|
|
stack.push(common.Bytes2Big(data)) |
|
|
|
case CALLDATASIZE: |
|
|
|
case CALLDATASIZE: |
|
|
|
l := int64(len(callData)) |
|
|
|
l := int64(len(input)) |
|
|
|
stack.push(big.NewInt(l)) |
|
|
|
stack.push(big.NewInt(l)) |
|
|
|
|
|
|
|
|
|
|
|
self.Printf(" => %d", l) |
|
|
|
|
|
|
|
case CALLDATACOPY: |
|
|
|
case CALLDATACOPY: |
|
|
|
var ( |
|
|
|
var ( |
|
|
|
mOff = stack.pop() |
|
|
|
mOff = stack.pop() |
|
|
|
cOff = stack.pop() |
|
|
|
cOff = stack.pop() |
|
|
|
l = stack.pop() |
|
|
|
l = stack.pop() |
|
|
|
) |
|
|
|
) |
|
|
|
data := getData(callData, cOff, l) |
|
|
|
data := getData(input, cOff, l) |
|
|
|
|
|
|
|
|
|
|
|
mem.Set(mOff.Uint64(), l.Uint64(), data) |
|
|
|
mem.Set(mOff.Uint64(), l.Uint64(), data) |
|
|
|
|
|
|
|
|
|
|
|
self.Printf(" => [%v, %v, %v]", mOff, cOff, l) |
|
|
|
|
|
|
|
case CODESIZE, EXTCODESIZE: |
|
|
|
case CODESIZE, EXTCODESIZE: |
|
|
|
var code []byte |
|
|
|
var code []byte |
|
|
|
if op == EXTCODESIZE { |
|
|
|
if op == EXTCODESIZE { |
|
|
@ -452,7 +403,6 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) { |
|
|
|
l := big.NewInt(int64(len(code))) |
|
|
|
l := big.NewInt(int64(len(code))) |
|
|
|
stack.push(l) |
|
|
|
stack.push(l) |
|
|
|
|
|
|
|
|
|
|
|
self.Printf(" => %d", l) |
|
|
|
|
|
|
|
case CODECOPY, EXTCODECOPY: |
|
|
|
case CODECOPY, EXTCODECOPY: |
|
|
|
var code []byte |
|
|
|
var code []byte |
|
|
|
if op == EXTCODECOPY { |
|
|
|
if op == EXTCODECOPY { |
|
|
@ -472,12 +422,9 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) { |
|
|
|
|
|
|
|
|
|
|
|
mem.Set(mOff.Uint64(), l.Uint64(), codeCopy) |
|
|
|
mem.Set(mOff.Uint64(), l.Uint64(), codeCopy) |
|
|
|
|
|
|
|
|
|
|
|
self.Printf(" => [%v, %v, %v] %x", mOff, cOff, l, codeCopy) |
|
|
|
|
|
|
|
case GASPRICE: |
|
|
|
case GASPRICE: |
|
|
|
stack.push(context.Price) |
|
|
|
stack.push(context.Price) |
|
|
|
|
|
|
|
|
|
|
|
self.Printf(" => %x", context.Price) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
case BLOCKHASH: |
|
|
|
case BLOCKHASH: |
|
|
|
num := stack.pop() |
|
|
|
num := stack.pop() |
|
|
|
|
|
|
|
|
|
|
@ -488,56 +435,47 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) { |
|
|
|
stack.push(common.Big0) |
|
|
|
stack.push(common.Big0) |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
self.Printf(" => 0x%x", stack.peek().Bytes()) |
|
|
|
|
|
|
|
case COINBASE: |
|
|
|
case COINBASE: |
|
|
|
coinbase := self.env.Coinbase() |
|
|
|
coinbase := self.env.Coinbase() |
|
|
|
|
|
|
|
|
|
|
|
stack.push(coinbase.Big()) |
|
|
|
stack.push(coinbase.Big()) |
|
|
|
|
|
|
|
|
|
|
|
self.Printf(" => 0x%x", coinbase) |
|
|
|
|
|
|
|
case TIMESTAMP: |
|
|
|
case TIMESTAMP: |
|
|
|
time := self.env.Time() |
|
|
|
time := self.env.Time() |
|
|
|
|
|
|
|
|
|
|
|
stack.push(big.NewInt(time)) |
|
|
|
stack.push(big.NewInt(time)) |
|
|
|
|
|
|
|
|
|
|
|
self.Printf(" => 0x%x", time) |
|
|
|
|
|
|
|
case NUMBER: |
|
|
|
case NUMBER: |
|
|
|
number := self.env.BlockNumber() |
|
|
|
number := self.env.BlockNumber() |
|
|
|
|
|
|
|
|
|
|
|
stack.push(U256(number)) |
|
|
|
stack.push(U256(number)) |
|
|
|
|
|
|
|
|
|
|
|
self.Printf(" => 0x%x", number.Bytes()) |
|
|
|
|
|
|
|
case DIFFICULTY: |
|
|
|
case DIFFICULTY: |
|
|
|
difficulty := self.env.Difficulty() |
|
|
|
difficulty := self.env.Difficulty() |
|
|
|
|
|
|
|
|
|
|
|
stack.push(difficulty) |
|
|
|
stack.push(difficulty) |
|
|
|
|
|
|
|
|
|
|
|
self.Printf(" => 0x%x", difficulty.Bytes()) |
|
|
|
|
|
|
|
case GASLIMIT: |
|
|
|
case GASLIMIT: |
|
|
|
self.Printf(" => %v", self.env.GasLimit()) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
stack.push(self.env.GasLimit()) |
|
|
|
stack.push(self.env.GasLimit()) |
|
|
|
|
|
|
|
|
|
|
|
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: |
|
|
|
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 - PUSH1 + 1)) |
|
|
|
size := uint64(op - PUSH1 + 1) |
|
|
|
byts := getData(code, new(big.Int).Add(pc, big.NewInt(1)), a) |
|
|
|
byts := getData(code, new(big.Int).SetUint64(pc+1), new(big.Int).SetUint64(size)) |
|
|
|
// push value to stack
|
|
|
|
// push value to stack
|
|
|
|
stack.push(common.Bytes2Big(byts)) |
|
|
|
stack.push(common.Bytes2Big(byts)) |
|
|
|
pc.Add(pc, a) |
|
|
|
pc += size |
|
|
|
|
|
|
|
|
|
|
|
self.Printf(" => 0x%x", byts) |
|
|
|
|
|
|
|
case POP: |
|
|
|
case POP: |
|
|
|
stack.pop() |
|
|
|
stack.pop() |
|
|
|
case DUP1, DUP2, DUP3, DUP4, DUP5, DUP6, DUP7, DUP8, DUP9, DUP10, DUP11, DUP12, DUP13, DUP14, DUP15, DUP16: |
|
|
|
case DUP1, DUP2, DUP3, DUP4, DUP5, DUP6, DUP7, DUP8, DUP9, DUP10, DUP11, DUP12, DUP13, DUP14, DUP15, DUP16: |
|
|
|
n := int(op - DUP1 + 1) |
|
|
|
n := int(op - DUP1 + 1) |
|
|
|
stack.dup(n) |
|
|
|
stack.dup(n) |
|
|
|
|
|
|
|
|
|
|
|
self.Printf(" => [%d] 0x%x", n, stack.peek().Bytes()) |
|
|
|
|
|
|
|
case SWAP1, SWAP2, SWAP3, SWAP4, SWAP5, SWAP6, SWAP7, SWAP8, SWAP9, SWAP10, SWAP11, SWAP12, SWAP13, SWAP14, SWAP15, SWAP16: |
|
|
|
case SWAP1, SWAP2, SWAP3, SWAP4, SWAP5, SWAP6, SWAP7, SWAP8, SWAP9, SWAP10, SWAP11, SWAP12, SWAP13, SWAP14, SWAP15, SWAP16: |
|
|
|
n := int(op - SWAP1 + 2) |
|
|
|
n := int(op - SWAP1 + 2) |
|
|
|
stack.swap(n) |
|
|
|
stack.swap(n) |
|
|
|
|
|
|
|
|
|
|
|
self.Printf(" => [%d]", n) |
|
|
|
|
|
|
|
case LOG0, LOG1, LOG2, LOG3, LOG4: |
|
|
|
case LOG0, LOG1, LOG2, LOG3, LOG4: |
|
|
|
n := int(op - LOG0) |
|
|
|
n := int(op - LOG0) |
|
|
|
topics := make([]common.Hash, n) |
|
|
|
topics := make([]common.Hash, n) |
|
|
@ -550,38 +488,32 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) { |
|
|
|
log := state.NewLog(context.Address(), topics, data, self.env.BlockNumber().Uint64()) |
|
|
|
log := state.NewLog(context.Address(), topics, data, self.env.BlockNumber().Uint64()) |
|
|
|
self.env.AddLog(log) |
|
|
|
self.env.AddLog(log) |
|
|
|
|
|
|
|
|
|
|
|
self.Printf(" => %v", log) |
|
|
|
|
|
|
|
case MLOAD: |
|
|
|
case MLOAD: |
|
|
|
offset := stack.pop() |
|
|
|
offset := stack.pop() |
|
|
|
val := common.BigD(mem.Get(offset.Int64(), 32)) |
|
|
|
val := common.BigD(mem.Get(offset.Int64(), 32)) |
|
|
|
stack.push(val) |
|
|
|
stack.push(val) |
|
|
|
|
|
|
|
|
|
|
|
self.Printf(" => 0x%x", val.Bytes()) |
|
|
|
|
|
|
|
case MSTORE: |
|
|
|
case MSTORE: |
|
|
|
// pop value of the stack
|
|
|
|
// pop value of the stack
|
|
|
|
mStart, val := stack.pop(), stack.pop() |
|
|
|
mStart, val := stack.pop(), stack.pop() |
|
|
|
mem.Set(mStart.Uint64(), 32, common.BigToBytes(val, 256)) |
|
|
|
mem.Set(mStart.Uint64(), 32, common.BigToBytes(val, 256)) |
|
|
|
|
|
|
|
|
|
|
|
self.Printf(" => 0x%x", val) |
|
|
|
|
|
|
|
case MSTORE8: |
|
|
|
case MSTORE8: |
|
|
|
off, val := stack.pop().Int64(), stack.pop().Int64() |
|
|
|
off, val := stack.pop().Int64(), stack.pop().Int64() |
|
|
|
|
|
|
|
|
|
|
|
mem.store[off] = byte(val & 0xff) |
|
|
|
mem.store[off] = byte(val & 0xff) |
|
|
|
|
|
|
|
|
|
|
|
self.Printf(" => [%v] 0x%x", off, mem.store[off]) |
|
|
|
|
|
|
|
case SLOAD: |
|
|
|
case SLOAD: |
|
|
|
loc := common.BigToHash(stack.pop()) |
|
|
|
loc := common.BigToHash(stack.pop()) |
|
|
|
val := common.Bytes2Big(statedb.GetState(context.Address(), loc)) |
|
|
|
val := common.Bytes2Big(statedb.GetState(context.Address(), loc)) |
|
|
|
stack.push(val) |
|
|
|
stack.push(val) |
|
|
|
|
|
|
|
|
|
|
|
self.Printf(" {0x%x : 0x%x}", loc, val.Bytes()) |
|
|
|
|
|
|
|
case SSTORE: |
|
|
|
case SSTORE: |
|
|
|
loc := common.BigToHash(stack.pop()) |
|
|
|
loc := common.BigToHash(stack.pop()) |
|
|
|
val := stack.pop() |
|
|
|
val := stack.pop() |
|
|
|
|
|
|
|
|
|
|
|
statedb.SetState(context.Address(), loc, val) |
|
|
|
statedb.SetState(context.Address(), loc, val) |
|
|
|
|
|
|
|
|
|
|
|
self.Printf(" {0x%x : 0x%x}", loc, val.Bytes()) |
|
|
|
|
|
|
|
case JUMP: |
|
|
|
case JUMP: |
|
|
|
if err := jump(pc, stack.pop()); err != nil { |
|
|
|
if err := jump(pc, stack.pop()); err != nil { |
|
|
|
return nil, err |
|
|
|
return nil, err |
|
|
@ -599,17 +531,14 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) { |
|
|
|
continue |
|
|
|
continue |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
self.Printf(" ~> false") |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
case JUMPDEST: |
|
|
|
case JUMPDEST: |
|
|
|
case PC: |
|
|
|
case PC: |
|
|
|
stack.push(pc) |
|
|
|
stack.push(new(big.Int).SetUint64(pc)) |
|
|
|
case MSIZE: |
|
|
|
case MSIZE: |
|
|
|
stack.push(big.NewInt(int64(mem.Len()))) |
|
|
|
stack.push(big.NewInt(int64(mem.Len()))) |
|
|
|
case GAS: |
|
|
|
case GAS: |
|
|
|
stack.push(context.Gas) |
|
|
|
stack.push(context.Gas) |
|
|
|
|
|
|
|
|
|
|
|
self.Printf(" => %x", context.Gas) |
|
|
|
|
|
|
|
case CREATE: |
|
|
|
case CREATE: |
|
|
|
|
|
|
|
|
|
|
|
var ( |
|
|
|
var ( |
|
|
@ -619,14 +548,12 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) { |
|
|
|
gas = new(big.Int).Set(context.Gas) |
|
|
|
gas = new(big.Int).Set(context.Gas) |
|
|
|
addr common.Address |
|
|
|
addr common.Address |
|
|
|
) |
|
|
|
) |
|
|
|
self.Endl() |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
context.UseGas(context.Gas) |
|
|
|
context.UseGas(context.Gas) |
|
|
|
ret, suberr, ref := self.env.Create(context, input, gas, price, value) |
|
|
|
ret, suberr, ref := self.env.Create(context, input, gas, price, value) |
|
|
|
if suberr != nil { |
|
|
|
if suberr != nil { |
|
|
|
stack.push(common.BigFalse) |
|
|
|
stack.push(common.BigFalse) |
|
|
|
|
|
|
|
|
|
|
|
self.Printf(" (*) 0x0 %v", suberr) |
|
|
|
|
|
|
|
} else { |
|
|
|
} else { |
|
|
|
// gas < len(ret) * CreateDataGas == NO_CODE
|
|
|
|
// gas < len(ret) * CreateDataGas == NO_CODE
|
|
|
|
dataGas := big.NewInt(int64(len(ret))) |
|
|
|
dataGas := big.NewInt(int64(len(ret))) |
|
|
@ -651,7 +578,6 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) { |
|
|
|
retOffset, retSize := stack.pop(), stack.pop() |
|
|
|
retOffset, retSize := stack.pop(), stack.pop() |
|
|
|
|
|
|
|
|
|
|
|
address := common.BigToAddress(addr) |
|
|
|
address := common.BigToAddress(addr) |
|
|
|
self.Printf(" => %x", address).Endl() |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Get the arguments from the memory
|
|
|
|
// Get the arguments from the memory
|
|
|
|
args := mem.Get(inOffset.Int64(), inSize.Int64()) |
|
|
|
args := mem.Get(inOffset.Int64(), inSize.Int64()) |
|
|
@ -673,47 +599,41 @@ func (self *Vm) Run(context *Context, callData []byte) (ret []byte, err error) { |
|
|
|
if err != nil { |
|
|
|
if err != nil { |
|
|
|
stack.push(common.BigFalse) |
|
|
|
stack.push(common.BigFalse) |
|
|
|
|
|
|
|
|
|
|
|
self.Printf("%v").Endl() |
|
|
|
|
|
|
|
} else { |
|
|
|
} else { |
|
|
|
stack.push(common.BigTrue) |
|
|
|
stack.push(common.BigTrue) |
|
|
|
|
|
|
|
|
|
|
|
mem.Set(retOffset.Uint64(), retSize.Uint64(), ret) |
|
|
|
mem.Set(retOffset.Uint64(), retSize.Uint64(), ret) |
|
|
|
} |
|
|
|
} |
|
|
|
self.Printf("resume %x (%v)", context.Address(), context.Gas) |
|
|
|
|
|
|
|
case RETURN: |
|
|
|
case RETURN: |
|
|
|
offset, size := stack.pop(), stack.pop() |
|
|
|
offset, size := stack.pop(), stack.pop() |
|
|
|
ret := mem.GetPtr(offset.Int64(), size.Int64()) |
|
|
|
ret := mem.GetPtr(offset.Int64(), size.Int64()) |
|
|
|
|
|
|
|
|
|
|
|
self.Printf(" => [%v, %v] (%d) 0x%x", offset, size, len(ret), ret).Endl() |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
return context.Return(ret), nil |
|
|
|
return context.Return(ret), nil |
|
|
|
case SUICIDE: |
|
|
|
case SUICIDE: |
|
|
|
receiver := statedb.GetOrNewStateObject(common.BigToAddress(stack.pop())) |
|
|
|
receiver := statedb.GetOrNewStateObject(common.BigToAddress(stack.pop())) |
|
|
|
balance := statedb.GetBalance(context.Address()) |
|
|
|
balance := statedb.GetBalance(context.Address()) |
|
|
|
|
|
|
|
|
|
|
|
self.Printf(" => (%x) %v", receiver.Address().Bytes()[:4], balance) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
receiver.AddBalance(balance) |
|
|
|
receiver.AddBalance(balance) |
|
|
|
|
|
|
|
|
|
|
|
statedb.Delete(context.Address()) |
|
|
|
statedb.Delete(context.Address()) |
|
|
|
|
|
|
|
|
|
|
|
fallthrough |
|
|
|
fallthrough |
|
|
|
case STOP: // Stop the context
|
|
|
|
case STOP: // Stop the context
|
|
|
|
self.Endl() |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
return context.Return(nil), nil |
|
|
|
return context.Return(nil), nil |
|
|
|
default: |
|
|
|
default: |
|
|
|
self.Printf("(pc) %-3v Invalid opcode %x\n", pc, op).Endl() |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
return nil, fmt.Errorf("Invalid opcode %x", op) |
|
|
|
return nil, fmt.Errorf("Invalid opcode %x", op) |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
pc.Add(pc, One) |
|
|
|
pc++ |
|
|
|
|
|
|
|
|
|
|
|
self.Endl() |
|
|
|
|
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// calculateGasAndSize calculates the required given the opcode and stack items calculates the new memorysize for
|
|
|
|
|
|
|
|
// the operation. This does not reduce gas or resizes the memory.
|
|
|
|
func (self *Vm) calculateGasAndSize(context *Context, caller ContextRef, op OpCode, statedb *state.StateDB, mem *Memory, stack *stack) (*big.Int, *big.Int, error) { |
|
|
|
func (self *Vm) calculateGasAndSize(context *Context, caller ContextRef, op OpCode, statedb *state.StateDB, mem *Memory, stack *stack) (*big.Int, *big.Int, error) { |
|
|
|
var ( |
|
|
|
var ( |
|
|
|
gas = new(big.Int) |
|
|
|
gas = new(big.Int) |
|
|
@ -855,40 +775,40 @@ func (self *Vm) calculateGasAndSize(context *Context, caller ContextRef, op OpCo |
|
|
|
return newMemSize, gas, nil |
|
|
|
return newMemSize, gas, nil |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
func (self *Vm) RunPrecompiled(p *PrecompiledAccount, callData []byte, context *Context) (ret []byte, err error) { |
|
|
|
// RunPrecompile runs and evaluate the output of a precompiled contract defined in contracts.go
|
|
|
|
gas := p.Gas(len(callData)) |
|
|
|
func (self *Vm) RunPrecompiled(p *PrecompiledAccount, input []byte, context *Context) (ret []byte, err error) { |
|
|
|
|
|
|
|
gas := p.Gas(len(input)) |
|
|
|
if context.UseGas(gas) { |
|
|
|
if context.UseGas(gas) { |
|
|
|
ret = p.Call(callData) |
|
|
|
ret = p.Call(input) |
|
|
|
self.Printf("NATIVE_FUNC => %x", ret) |
|
|
|
|
|
|
|
self.Endl() |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
return context.Return(ret), nil |
|
|
|
return context.Return(ret), nil |
|
|
|
} else { |
|
|
|
} else { |
|
|
|
self.Printf("NATIVE_FUNC => failed").Endl() |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
tmp := new(big.Int).Set(context.Gas) |
|
|
|
tmp := new(big.Int).Set(context.Gas) |
|
|
|
|
|
|
|
|
|
|
|
return nil, OOG(gas, tmp) |
|
|
|
return nil, OOG(gas, tmp) |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
func (self *Vm) Printf(format string, v ...interface{}) VirtualMachine { |
|
|
|
// log emits a log event to the environment for each opcode encountered. This is not to be confused with the
|
|
|
|
if self.debug { |
|
|
|
// LOG* opcode.
|
|
|
|
self.logStr += fmt.Sprintf(format, v...) |
|
|
|
func (self *Vm) log(pc uint64, op OpCode, gas, cost *big.Int, memory *Memory, stack *stack, context *Context) { |
|
|
|
} |
|
|
|
if Debug { |
|
|
|
|
|
|
|
mem := make([]byte, len(memory.Data())) |
|
|
|
|
|
|
|
copy(mem, memory.Data()) |
|
|
|
|
|
|
|
stck := make([]*big.Int, len(stack.Data())) |
|
|
|
|
|
|
|
copy(stck, stack.Data()) |
|
|
|
|
|
|
|
|
|
|
|
return self |
|
|
|
object := context.self.(*state.StateObject) |
|
|
|
} |
|
|
|
storage := make(map[common.Hash][]byte) |
|
|
|
|
|
|
|
object.EachStorage(func(k, v []byte) { |
|
|
|
|
|
|
|
storage[common.BytesToHash(k)] = v |
|
|
|
|
|
|
|
}) |
|
|
|
|
|
|
|
|
|
|
|
func (self *Vm) Endl() VirtualMachine { |
|
|
|
self.env.AddStructLog(StructLog{pc, op, new(big.Int).Set(gas), cost, mem, stck, storage}) |
|
|
|
if self.debug { |
|
|
|
|
|
|
|
glog.V(0).Infoln(self.logStr) |
|
|
|
|
|
|
|
self.logStr = "" |
|
|
|
|
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
return self |
|
|
|
|
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Environment returns the current workable state of the VM
|
|
|
|
func (self *Vm) Env() Environment { |
|
|
|
func (self *Vm) Env() Environment { |
|
|
|
return self.env |
|
|
|
return self.env |
|
|
|
} |
|
|
|
} |
|
|
|