mirror
/
go-ethereum
mirror of https://github.com/ethereum/go-ethereum
2
0
Fork 1
Code Issues Releases Wiki Activity

Precompiled crypto contracts

Browse Source
pull/150/head
obscuren 10 years ago
parent 9b60cf267a
commit f3196c915a
2 changed files with 73 additions and 60 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 44
      ethvm/address.go
  2. 89
      ethvm/vm.go

44
ethvm/address.go
Unescape View File

@ -0,0 +1,44 @@
package ethvm
import (
"math/big"
"github.com/ethereum/eth-go/ethcrypto"
"github.com/ethereum/eth-go/ethutil"
)
type Address interface {
Call(in []byte) []byte
}
type PrecompiledAddress struct {
Gas *big.Int
fn func(in []byte) []byte
}
func (self PrecompiledAddress) Call(in []byte) []byte {
return self.fn(in)
}
var Precompiled = map[uint64]*PrecompiledAddress{
1: &PrecompiledAddress{big.NewInt(500), ecrecoverFunc},
2: &PrecompiledAddress{big.NewInt(100), sha256Func},
3: &PrecompiledAddress{big.NewInt(100), ripemd160Func},
}
var NoAddr = PrecompiledAddress{}
func sha256Func(in []byte) []byte {
return ethcrypto.Sha256(in)
}
func ripemd160Func(in []byte) []byte {
return ethutil.RightPadBytes(ethcrypto.Ripemd160(in), 32)
}
func ecrecoverFunc(in []byte) []byte {
// In case of an invalid sig. Defaults to return nil
defer func() { recover() }()
return ethcrypto.Ecrecover(in)
}

89
ethvm/vm.go
Unescape View File

@ -1,7 +1,6 @@
package ethvm
import (
"container/list"
"fmt"
"math/big"
@ -35,8 +34,6 @@ type Vm struct {
Fn string
Recoverable bool
queue *list.List
}
type Environment interface {
@ -63,7 +60,7 @@ func New(env Environment) *Vm {
lt = LogTyDiff
}
return &Vm{env: env, logTy: lt, Recoverable: true, queue: list.New()}
return &Vm{env: env, logTy: lt, Recoverable: true}
}
func calcMemSize(off, l *big.Int) *big.Int {
@ -86,7 +83,6 @@ func (self *Vm) RunClosure(closure *Closure) (ret []byte, err error) {
if r := recover(); r != nil {
ret = closure.Return(nil)
err = fmt.Errorf("%v", r)
vmlogger.Errorln("vm err", err)
}
}()
}
@ -211,7 +207,7 @@ func (self *Vm) RunClosure(closure *Closure) (ret []byte, err error) {
require(4)
newMemSize = calcMemSize(stack.data[stack.Len()-2], stack.data[stack.Len()-4])
case CALL, CALLSTATELESS:
case CALL, CALLCODE:
require(7)
gas.Set(GasCall)
addStepGasUsage(stack.data[stack.Len()-1])
@ -733,12 +729,16 @@ func (self *Vm) RunClosure(closure *Closure) (ret []byte, err error) {
if cond.Cmp(ethutil.BigTrue) >= 0 {
pc = pos
self.Printf(" ~> %v (t)", pc).Endl()
if OpCode(closure.Get(pc).Uint()) != JUMPDEST {
return closure.Return(nil), fmt.Errorf("JUMP missed JUMPDEST %v", pc)
}
continue
} else {
self.Printf(" (f)")
}
case JUMPDEST:
self.Printf(" ~> %v (t)", pc).Endl()
case PC:
stack.Push(pc)
case MSIZE:
@ -772,7 +772,7 @@ func (self *Vm) RunClosure(closure *Closure) (ret []byte, err error) {
closure.UseGas(closure.Gas)
msg := NewMessage(self, addr, input, gas, closure.Price, value)
msg := NewExecution(self, addr, input, gas, closure.Price, value)
ret, err := msg.Exec(addr, closure)
if err != nil {
stack.Push(ethutil.BigFalse)
@ -793,7 +793,7 @@ func (self *Vm) RunClosure(closure *Closure) (ret []byte, err error) {
if self.Dbg != nil {
self.Dbg.SetCode(closure.Code)
}
case CALL, CALLSTATELESS:
case CALL, CALLCODE:
require(7)
self.Endl()
@ -812,13 +812,13 @@ func (self *Vm) RunClosure(closure *Closure) (ret []byte, err error) {
snapshot := self.env.State().Copy()
var executeAddr []byte
if op == CALLSTATELESS {
if op == CALLCODE {
executeAddr = closure.Address()
} else {
executeAddr = addr.Bytes()
}
msg := NewMessage(self, executeAddr, args, gas, closure.Price, value)
msg := NewExecution(self, executeAddr, args, gas, closure.Price, value)
ret, err := msg.Exec(addr.Bytes(), closure)
if err != nil {
stack.Push(ethutil.BigFalse)
@ -835,22 +835,6 @@ func (self *Vm) RunClosure(closure *Closure) (ret []byte, err error) {
self.Dbg.SetCode(closure.Code)
}
case POST:
require(5)
self.Endl()
gas := stack.Pop()
// Pop gas and value of the stack.
value, addr := stack.Popn()
// Pop input size and offset
inSize, inOffset := stack.Popn()
// Get the arguments from the memory
args := mem.Get(inOffset.Int64(), inSize.Int64())
msg := NewMessage(self, addr.Bytes(), args, gas, closure.Price, value)
msg.Postpone()
case RETURN:
require(2)
size, offset := stack.Popn()
@ -904,10 +888,6 @@ func (self *Vm) RunClosure(closure *Closure) (ret []byte, err error) {
}
}
func (self *Vm) Queue() *list.List {
return self.queue
}
func (self *Vm) Printf(format string, v ...interface{}) *Vm {
if self.Verbose && self.logTy == LogTyPretty {
self.logStr += fmt.Sprintf(format, v...)
@ -940,7 +920,7 @@ func ensure256(x *big.Int) {
}
}
type Message struct {
type Execution struct {
vm *Vm
closure *Closure
address, input []byte
@ -948,30 +928,15 @@ type Message struct {
object *ethstate.StateObject
}
func NewMessage(vm *Vm, address, input []byte, gas, gasPrice, value *big.Int) *Message {
return &Message{vm: vm, address: address, input: input, gas: gas, price: gasPrice, value: value}
func NewExecution(vm *Vm, address, input []byte, gas, gasPrice, value *big.Int) *Execution {
return &Execution{vm: vm, address: address, input: input, gas: gas, price: gasPrice, value: value}
}
func (self *Message) Postpone() {
self.vm.queue.PushBack(self)
}
func (self *Message) Addr() []byte {
func (self *Execution) Addr() []byte {
return self.address
}
func (self *Message) Exec(codeAddr []byte, caller ClosureRef) (ret []byte, err error) {
queue := self.vm.queue
self.vm.queue = list.New()
defer func() {
if err == nil {
queue.PushBackList(self.vm.queue)
}
self.vm.queue = queue
}()
func (self *Execution) Exec(codeAddr []byte, caller ClosureRef) (ret []byte, err error) {
msg := self.vm.env.State().Manifest().AddMessage(&ethstate.Message{
To: self.address, From: caller.Address(),
Input: self.input,
@ -992,17 +957,21 @@ func (self *Message) Exec(codeAddr []byte, caller ClosureRef) (ret []byte, err e
caller.Object().SubAmount(self.value)
stateObject.AddAmount(self.value)
// Retrieve the executing code
code := self.vm.env.State().GetCode(codeAddr)
// Create a new callable closure
c := NewClosure(msg, caller, stateObject, code, self.gas, self.price)
// Executer the closure and get the return value (if any)
ret, _, err = c.Call(self.vm, self.input)
if p := Precompiled[ethutil.BigD(codeAddr).Uint64()]; p != nil {
if self.gas.Cmp(p.Gas) >= 0 {
ret = p.Call(self.input)
}
} else {
// Retrieve the executing code
code := self.vm.env.State().GetCode(codeAddr)
msg.Output = ret
// Create a new callable closure
c := NewClosure(msg, caller, stateObject, code, self.gas, self.price)
// Executer the closure and get the return value (if any)
ret, _, err = c.Call(self.vm, self.input)
return ret, err
msg.Output = ret
}
}
return

Write Preview
Loading…
Cancel
Save