From 4dbdcaecb117d7e1fcaf0869f5d4602312552991 Mon Sep 17 00:00:00 2001
From: obscuren <geffobscura@gmail.com>
Date: Wed, 17 Dec 2014 23:58:52 +0100
Subject: Moved pre-compiled, moved depth check

* Depth check has been moved to the execution
* Pre compiled execution has been moved to the VM
* PrecompiledAddress has been renamed to PrecompiledAccount
---
 core/execution.go | 20 +++++++-------------
 vm/address.go     | 12 ++++++------
 vm/common.go      |  2 +-
 vm/vm_debug.go    | 24 +++++++++++++++++++++---
 4 files changed, 35 insertions(+), 23 deletions(-)

diff --git a/core/execution.go b/core/execution.go
index 58d46c509..827e1ee0e 100644
--- a/core/execution.go
+++ b/core/execution.go
@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"math/big"
 
-	"github.com/ethereum/go-ethereum/ethutil"
 	"github.com/ethereum/go-ethereum/state"
 	"github.com/ethereum/go-ethereum/vm"
 )
@@ -36,6 +35,11 @@ func (self *Execution) exec(code, contextAddr []byte, caller vm.ClosureRef) (ret
 	env := self.vm.Env()
 	chainlogger.Debugf("pre state %x\n", env.State().Root())
 
+	if self.vm.Env().Depth() == vm.MaxCallDepth {
+		// Consume all gas (by not returning it) and return a depth error
+		return nil, vm.DepthError{}
+	}
+
 	from, to := env.State().GetStateObject(caller.Address()), env.State().GetOrNewStateObject(self.address)
 	// Skipping transfer is used on testing for the initial call
 	if !self.SkipTransfer {
@@ -50,24 +54,14 @@ func (self *Execution) exec(code, contextAddr []byte, caller vm.ClosureRef) (ret
 
 	snapshot := env.State().Copy()
 	defer func() {
-		if vm.IsDepthErr(err) || vm.IsOOGErr(err) {
+		if /*vm.IsDepthErr(err) ||*/ vm.IsOOGErr(err) {
 			env.State().Set(snapshot)
 		}
 		chainlogger.Debugf("post state %x\n", env.State().Root())
 	}()
 
 	self.object = to
-	// Pre-compiled contracts (address.go) 1, 2 & 3.
-	naddr := ethutil.BigD(contextAddr).Uint64()
-	if p := vm.Precompiled[naddr]; p != nil {
-		if self.Gas.Cmp(p.Gas(len(self.input))) >= 0 {
-			ret = p.Call(self.input)
-			self.vm.Printf("NATIVE_FUNC(%x) => %x", naddr, ret)
-			self.vm.Endl()
-		}
-	} else {
-		ret, err = self.vm.Run(to, caller, code, self.value, self.Gas, self.price, self.input)
-	}
+	ret, err = self.vm.Run(to, caller, code, self.value, self.Gas, self.price, self.input)
 
 	return
 }
diff --git a/vm/address.go b/vm/address.go
index be8921a3b..611979c94 100644
--- a/vm/address.go
+++ b/vm/address.go
@@ -11,25 +11,25 @@ type Address interface {
 	Call(in []byte) []byte
 }
 
-type PrecompiledAddress struct {
+type PrecompiledAccount struct {
 	Gas func(l int) *big.Int
 	fn  func(in []byte) []byte
 }
 
-func (self PrecompiledAddress) Call(in []byte) []byte {
+func (self PrecompiledAccount) Call(in []byte) []byte {
 	return self.fn(in)
 }
 
-var Precompiled = map[uint64]*PrecompiledAddress{
-	1: &PrecompiledAddress{func(l int) *big.Int {
+var Precompiled = map[string]*PrecompiledAccount{
+	string(ethutil.LeftPadBytes([]byte{1}, 20)): &PrecompiledAccount{func(l int) *big.Int {
 		return GasEcrecover
 	}, ecrecoverFunc},
-	2: &PrecompiledAddress{func(l int) *big.Int {
+	string(ethutil.LeftPadBytes([]byte{2}, 20)): &PrecompiledAccount{func(l int) *big.Int {
 		n := big.NewInt(int64(l+31)/32 + 1)
 		n.Mul(n, GasSha256)
 		return n
 	}, sha256Func},
-	3: &PrecompiledAddress{func(l int) *big.Int {
+	string(ethutil.LeftPadBytes([]byte{3}, 20)): &PrecompiledAccount{func(l int) *big.Int {
 		n := big.NewInt(int64(l+31)/32 + 1)
 		n.Mul(n, GasRipemd)
 		return n
diff --git a/vm/common.go b/vm/common.go
index 592d44ccd..3d6d377ca 100644
--- a/vm/common.go
+++ b/vm/common.go
@@ -48,7 +48,7 @@ var (
 	S256 = ethutil.S256
 )
 
-const MaxCallDepth = 1025
+const MaxCallDepth = 1024
 
 func calcMemSize(off, l *big.Int) *big.Int {
 	if l.Cmp(ethutil.Big0) == 0 {
diff --git a/vm/vm_debug.go b/vm/vm_debug.go
index 8af1979b1..9da832a79 100644
--- a/vm/vm_debug.go
+++ b/vm/vm_debug.go
@@ -48,9 +48,8 @@ func (self *DebugVm) Run(me, caller ClosureRef, code []byte, value, gas, price *
 	})
 	closure := NewClosure(msg, caller, me, code, gas, price)
 
-	if self.env.Depth() == MaxCallDepth {
-		//closure.UseGas(gas)
-		return closure.Return(nil), DepthError{}
+	if p := Precompiled[string(me.Address())]; p != nil {
+		return self.RunPrecompiled(p, callData, closure)
 	}
 
 	if self.Recoverable {
@@ -941,6 +940,25 @@ func (self *DebugVm) Run(me, caller ClosureRef, code []byte, value, gas, price *
 	}
 }
 
+func (self *DebugVm) RunPrecompiled(p *PrecompiledAccount, callData []byte, closure *Closure) (ret []byte, err error) {
+	gas := p.Gas(len(callData))
+	if closure.UseGas(gas) {
+		ret = p.Call(callData)
+		self.Printf("NATIVE_FUNC => %x", ret)
+		self.Endl()
+
+		return closure.Return(ret), nil
+	} else {
+		self.Endl()
+
+		tmp := new(big.Int).Set(closure.Gas)
+
+		closure.UseGas(closure.Gas)
+
+		return closure.Return(nil), OOG(gas, tmp)
+	}
+}
+
 func (self *DebugVm) Printf(format string, v ...interface{}) VirtualMachine {
 	if self.logTy == LogTyPretty {
 		self.logStr += fmt.Sprintf(format, v...)
-- 
cgit v1.2.3