From acf4b5753fd473f048176a12c42e1b8209035b57 Mon Sep 17 00:00:00 2001
From: obscuren <geffobscura@gmail.com>
Date: Tue, 9 Dec 2014 20:27:57 +0100
Subject: Core changes

* Code = '' if gas < len(D) * 5
* Sha3 gas   10 + 10 * len(D), rounding up 32 bytes
* Sha256 gas 50 + 50 * len(D), rounding up 32 bytes
* Ripmed gas 50 + 50 * len(D), rounding up 32 bytes
* Accounts and value transfers no longer reverted
---
 core/execution.go | 16 ++++++++--------
 vm/address.go     | 18 ++++++++++++++----
 vm/common.go      |  7 +++++++
 vm/vm_debug.go    | 14 +++++++++++---
 4 files changed, 40 insertions(+), 15 deletions(-)

diff --git a/core/execution.go b/core/execution.go
index 9f9d9a5d9..5176f7351 100644
--- a/core/execution.go
+++ b/core/execution.go
@@ -34,8 +34,14 @@ func (self *Execution) Call(codeAddr []byte, caller vm.ClosureRef) ([]byte, erro
 
 func (self *Execution) exec(code, caddr []byte, caller vm.ClosureRef) (ret []byte, err error) {
 	env := self.vm.Env()
-
 	chainlogger.Debugf("pre state %x\n", env.State().Root())
+
+	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 {
+		err = env.Transfer(from, to, self.value)
+	}
+
 	snapshot := env.State().Copy()
 	defer func() {
 		if vm.IsDepthErr(err) || vm.IsOOGErr(err) {
@@ -44,12 +50,6 @@ func (self *Execution) exec(code, caddr []byte, caller vm.ClosureRef) (ret []byt
 		chainlogger.Debugf("post state %x\n", env.State().Root())
 	}()
 
-	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 {
-		err = env.Transfer(from, to, self.value)
-	}
-
 	if err != nil {
 		caller.ReturnGas(self.Gas, self.price)
 
@@ -59,7 +59,7 @@ func (self *Execution) exec(code, caddr []byte, caller vm.ClosureRef) (ret []byt
 		// Pre-compiled contracts (address.go) 1, 2 & 3.
 		naddr := ethutil.BigD(caddr).Uint64()
 		if p := vm.Precompiled[naddr]; p != nil {
-			if self.Gas.Cmp(p.Gas) >= 0 {
+			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()
diff --git a/vm/address.go b/vm/address.go
index 06bd35f6b..be8921a3b 100644
--- a/vm/address.go
+++ b/vm/address.go
@@ -12,7 +12,7 @@ type Address interface {
 }
 
 type PrecompiledAddress struct {
-	Gas *big.Int
+	Gas func(l int) *big.Int
 	fn  func(in []byte) []byte
 }
 
@@ -21,9 +21,19 @@ func (self PrecompiledAddress) Call(in []byte) []byte {
 }
 
 var Precompiled = map[uint64]*PrecompiledAddress{
-	1: &PrecompiledAddress{big.NewInt(500), ecrecoverFunc},
-	2: &PrecompiledAddress{big.NewInt(100), sha256Func},
-	3: &PrecompiledAddress{big.NewInt(100), ripemd160Func},
+	1: &PrecompiledAddress{func(l int) *big.Int {
+		return GasEcrecover
+	}, ecrecoverFunc},
+	2: &PrecompiledAddress{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 {
+		n := big.NewInt(int64(l+31)/32 + 1)
+		n.Mul(n, GasRipemd)
+		return n
+	}, ripemd160Func},
 }
 
 func sha256Func(in []byte) []byte {
diff --git a/vm/common.go b/vm/common.go
index 9514ff6d3..5fd512687 100644
--- a/vm/common.go
+++ b/vm/common.go
@@ -27,10 +27,17 @@ var (
 	GasBalance      = big.NewInt(20)
 	GasCreate       = big.NewInt(100)
 	GasCall         = big.NewInt(20)
+	GasCreateByte   = big.NewInt(5)
+	GasSha3Byte     = big.NewInt(10)
+	GasSha256Byte   = big.NewInt(50)
+	GasRipemdByte   = big.NewInt(50)
 	GasMemory       = big.NewInt(1)
 	GasData         = big.NewInt(5)
 	GasTx           = big.NewInt(500)
 	GasLog          = big.NewInt(32)
+	GasSha256       = big.NewInt(50)
+	GasRipemd       = big.NewInt(50)
+	GasEcrecover    = big.NewInt(100)
 
 	Pow256 = ethutil.BigPow(2, 256)
 
diff --git a/vm/vm_debug.go b/vm/vm_debug.go
index be1c59339..c0a2d6d98 100644
--- a/vm/vm_debug.go
+++ b/vm/vm_debug.go
@@ -254,9 +254,12 @@ func (self *DebugVm) Run(me, caller ClosureRef, code []byte, value, gas, price *
 			newMemSize.Mul(newMemSize, u256(32))
 
 			switch op {
-			// Additional gas usage on *CODPY
 			case CALLDATACOPY, CODECOPY, EXTCODECOPY:
 				addStepGasUsage(new(big.Int).Div(newMemSize, u256(32)))
+			case SHA3:
+				g := new(big.Int).Div(newMemSize, u256(32))
+				g.Mul(g, GasSha3Byte)
+				addStepGasUsage(g)
 			}
 
 			if newMemSize.Cmp(u256(int64(mem.Len()))) > 0 {
@@ -833,8 +836,13 @@ func (self *DebugVm) Run(me, caller ClosureRef, code []byte, value, gas, price *
 
 				self.Printf("CREATE err %v", err)
 			} else {
-				ref.SetCode(ret)
-				msg.Output = ret
+				// gas < len(ret) * CreateDataGas == NO_CODE
+				dataGas := big.NewInt(int64(len(ret)))
+				dataGas.Mul(dataGas, GasCreateByte)
+				if closure.UseGas(dataGas) {
+					ref.SetCode(ret)
+					msg.Output = ret
+				}
 
 				stack.Push(ethutil.BigD(addr))
 			}
-- 
cgit