forks/go-ethereum
1
0
Fork 1
mirror of https://github.com/ethereum/go-ethereum.git synced 2026-07-22 04:36:42 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Merge remote-tracking branch 'upstream/develop' into pr/evmjit

Browse source 
Conflicts:
	.gitignore
	vm/vm_jit.go
This commit is contained in:
Paweł Bylica 2015-01-20 22:34:45 +01:00
commit 96b15abff6
19 changed files with 1581 additions and 1033 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
.gitignore vendored
View file

@ -10,5 +10,8 @@
.DS_Store
*/**/.DS_Store
.ethtest
*.project
/.settings/
#*
.#*
*#
*~

3
cmd/mist/assets/debugger/debugger.qml
View file

@ -19,7 +19,7 @@ ApplicationWindow {
property alias dataText: rawDataField.text
onClosing: {
dbg.Stop()
//dbg.Stop()
}
menuBar: MenuBar {
@ -353,6 +353,7 @@ ApplicationWindow {
ComboBox {
visible: false
id: snippets
anchors.right: parent.right
model: ListModel {

28
cmd/mist/assets/qml/browser.qml
View file

@ -9,6 +9,10 @@ import Ethereum 1.0
Rectangle {
id: window
objectName: "browserView"
anchors.fill: parent
color: "#00000000"
property var title: "Browser"
property var iconSource: "../browser.png"
property var menuItem
@ -106,10 +110,9 @@ Rectangle {
anchors {
left: back.right
right: toggleInspector.left
leftMargin: 5
rightMargin: 5
leftMargin: 10
rightMargin: 10
}
//text: "http://etherian.io"
text: webview.url;
id: uriNav
y: parent.height / 2 - this.height / 2
@ -136,6 +139,18 @@ Rectangle {
}
}
// Border
Rectangle {
id: divider
anchors {
left: parent.left
right: parent.right
top: navBar.bottom
}
z: -1
height: 1
color: "#CCCCCC"
}
WebView {
objectName: "webView"
@ -144,12 +159,7 @@ Rectangle {
left: parent.left
right: parent.right
bottom: parent.bottom
top: navBar.bottom
}
//property var cleanPath: false
onNavigationRequested: {
window.open(request.url.toString());
top: divider.bottom
}
function injectJs(js) {

19
cmd/mist/assets/qml/main.qml
View file

@ -63,6 +63,17 @@ ApplicationWindow {
gui.sendCommand(0)
}
function activeView(view, menuItem) {
mainSplit.setView(view, menuItem)
if (view.objectName === "browserView") {
urlPane.visible = false;
mainView.anchors.top = rootView.top
} else {
urlPane.visible = true;
mainView.anchors.top = divider.bottom
}
}
function addViews(view, path, options) {
var views = mainSplit.addComponent(view, options)
views.menuItem.path = path
@ -284,6 +295,7 @@ ApplicationWindow {
}
ProgressBar {
visible: false
id: downloadIndicator
value: 0
objectName: "downloadIndicator"
@ -293,6 +305,7 @@ ApplicationWindow {
}
Label {
visible: false
objectName: "downloadLabel"
//y: 7
anchors.left: downloadIndicator.right
@ -445,7 +458,7 @@ ApplicationWindow {
MouseArea {
anchors.fill: parent
onClicked: {
mainSplit.setView(view, menuItem)
activeView(view, menuItem);
}
}
@ -606,6 +619,7 @@ ApplicationWindow {
* Main view
********************/
Rectangle {
id: rootView
anchors.right: parent.right
anchors.left: menu.right
anchors.bottom: parent.bottom
@ -639,8 +653,7 @@ ApplicationWindow {
Keys.onReturnPressed: {
if(/^https?/.test(this.text)) {
root.browser.view.open(this.text);
mainSplit.setView(root.browser.view, root.browser.menuItem);
activeView(root.browser.view, root.browser.menuItem);
} else {
addPlugin(this.text, {close: true, section: "apps"})
}

7
cmd/mist/debugger.go
View file

@ -40,7 +40,7 @@ type DebuggerWindow struct {
engine *qml.Engine
lib *UiLib
vm *vm.DebugVm
vm *vm.Vm
Db *Debugger
state *state.StateDB
@ -57,7 +57,7 @@ func NewDebuggerWindow(lib *UiLib) *DebuggerWindow {
win := component.CreateWindow(nil)
w := &DebuggerWindow{engine: engine, win: win, lib: lib, vm: &vm.DebugVm{}}
w := &DebuggerWindow{engine: engine, win: win, lib: lib, vm: &vm.Vm{}}
w.Db = NewDebugger(w)
return w
@ -267,6 +267,9 @@ type storeVal struct {
Key, Value string
}
func (self *Debugger) Step(evm vm.VirtualMachine, op vm.OpCode, mem *vm.Memory, stack *vm.Stack, context *vm.Context) {
}
func (self *Debugger) BreakHook(pc int, op vm.OpCode, mem *vm.Memory, stack *vm.Stack, stateObject *state.StateObject) bool {
self.main.Logln("break on instr:", pc)

6
cmd/mist/ui_lib.go
View file

@ -212,16 +212,16 @@ func (self *UiLib) StartDbWithContractAndData(contractHash, data string) {
dbWindow := NewDebuggerWindow(self)
object := self.eth.ChainManager().State().GetStateObject(ethutil.Hex2Bytes(contractHash))
if len(object.Code) > 0 {
dbWindow.SetCode("0x" + ethutil.Bytes2Hex(object.Code))
dbWindow.SetCode(ethutil.Bytes2Hex(object.Code))
}
dbWindow.SetData("0x" + data)
dbWindow.SetData(data)
dbWindow.Show()
}
func (self *UiLib) StartDbWithCode(code string) {
dbWindow := NewDebuggerWindow(self)
dbWindow.SetCode("0x" + code)
dbWindow.SetCode(code)
dbWindow.Show()
}

2
core/execution.go
View file

@ -33,7 +33,7 @@ func (self *Execution) Call(codeAddr []byte, caller vm.ContextRef) ([]byte, erro
func (self *Execution) exec(code, contextAddr []byte, caller vm.ContextRef) (ret []byte, err error) {
env := self.env
evm := vm.New(env, vm.DebugVmTy)
evm := vm.New(env)
if env.Depth() == vm.MaxCallDepth {
caller.ReturnGas(self.Gas, self.price)

13
crypto/crypto_test.go
View file

@ -6,6 +6,9 @@ import (
"fmt"
"testing"
"time"
"github.com/ethereum/go-ethereum/ethutil"
"github.com/obscuren/secp256k1-go"
)
// These tests are sanity checks.
@ -47,3 +50,13 @@ func BenchmarkSha3(b *testing.B) {
fmt.Println(amount, ":", time.Since(start))
}
func Test0Key(t *testing.T) {
key := ethutil.Hex2Bytes("1111111111111111111111111111111111111111111111111111111111111111")
p, err := secp256k1.GeneratePubKey(key)
addr := Sha3(p[1:])[12:]
fmt.Printf("%x\n", p)
fmt.Printf("%v %x\n", err, addr)
}

107
crypto/key.go Normal file
View file

@ -0,0 +1,107 @@
/*
This file is part of go-ethereum
go-ethereum is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
go-ethereum is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
*/
/**
* @authors
* Gustav Simonsson <gustav.simonsson@gmail.com>
* @date 2015
*
*/
package crypto
import (
"bytes"
"code.google.com/p/go-uuid/uuid"
"crypto/ecdsa"
"crypto/elliptic"
"encoding/json"
"io"
)
type Key struct {
Id *uuid.UUID // Version 4 "random" for unique id not derived from key data
// we only store privkey as pubkey/address can be derived from it
// privkey in this struct is always in plaintext
PrivateKey *ecdsa.PrivateKey
}
type plainKeyJSON struct {
Id []byte
PrivateKey []byte
}
type cipherJSON struct {
Salt []byte
IV []byte
CipherText []byte
}
type encryptedKeyJSON struct {
Id []byte
Crypto cipherJSON
}
func (k *Key) Address() []byte {
pubBytes := FromECDSAPub(&k.PrivateKey.PublicKey)
return Sha3(pubBytes)[12:]
}
func (k *Key) MarshalJSON() (j []byte, err error) {
jStruct := plainKeyJSON{
*k.Id,
FromECDSA(k.PrivateKey),
}
j, err = json.Marshal(jStruct)
return j, err
}
func (k *Key) UnmarshalJSON(j []byte) (err error) {
keyJSON := new(plainKeyJSON)
err = json.Unmarshal(j, &keyJSON)
if err != nil {
return err
}
u := new(uuid.UUID)
*u = keyJSON.Id
k.Id = u
k.PrivateKey = ToECDSA(keyJSON.PrivateKey)
return err
}
func NewKey(rand io.Reader) *Key {
randBytes := make([]byte, 32)
_, err := rand.Read(randBytes)
if err != nil {
panic("key generation: could not read from random source: " + err.Error())
}
reader := bytes.NewReader(randBytes)
_, x, y, err := elliptic.GenerateKey(S256(), reader)
if err != nil {
panic("key generation: elliptic.GenerateKey failed: " + err.Error())
}
privateKeyMarshalled := elliptic.Marshal(S256(), x, y)
privateKeyECDSA := ToECDSA(privateKeyMarshalled)
key := new(Key)
id := uuid.NewRandom()
key.Id = &id
key.PrivateKey = privateKeyECDSA
return key
}

245
crypto/key_store_passphrase.go Normal file
View file

@ -0,0 +1,245 @@
/*
This file is part of go-ethereum
go-ethereum is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
go-ethereum is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
*/
/**
* @authors
* Gustav Simonsson <gustav.simonsson@gmail.com>
* @date 2015
*
*/
/*
This key store behaves as KeyStorePlain with the difference that
the private key is encrypted and on disk uses another JSON encoding.
Cryptography:
1. Encryption key is scrypt derived key from user passphrase. Scrypt parameters
(work factors) [1][2] are defined as constants below.
2. Scrypt salt is 32 random bytes from CSPRNG. It is appended to ciphertext.
3. Checksum is SHA3 of the private key bytes.
4. Plaintext is concatenation of private key bytes and checksum.
5. Encryption algo is AES 256 CBC [3][4]
6. CBC IV is 16 random bytes from CSPRNG. It is appended to ciphertext.
7. Plaintext padding is PKCS #7 [5][6]
Encoding:
1. On disk, ciphertext, salt and IV are encoded in a nested JSON object.
cat a key file to see the structure.
2. byte arrays are base64 JSON strings.
3. The EC private key bytes are in uncompressed form [7].
They are a big-endian byte slice of the absolute value of D [8][9].
4. The checksum is the last 32 bytes of the plaintext byte array and the
private key is the preceeding bytes.
References:
1. http://www.tarsnap.com/scrypt/scrypt-slides.pdf
2. http://stackoverflow.com/questions/11126315/what-are-optimal-scrypt-work-factors
3. http://en.wikipedia.org/wiki/Advanced_Encryption_Standard
4. http://en.wikipedia.org/wiki/Block_cipher_mode_of_operation#Cipher-block_chaining_.28CBC.29
5. https://leanpub.com/gocrypto/read#leanpub-auto-block-cipher-modes
6. http://tools.ietf.org/html/rfc2315
7. http://bitcoin.stackexchange.com/questions/3059/what-is-a-compressed-bitcoin-key
8. http://golang.org/pkg/crypto/ecdsa/#PrivateKey
9. https://golang.org/pkg/math/big/#Int.Bytes
*/
package crypto
import (
"bytes"
"code.google.com/p/go-uuid/uuid"
"code.google.com/p/go.crypto/scrypt"
"crypto/aes"
"crypto/cipher"
crand "crypto/rand"
"encoding/json"
"errors"
"io"
"os"
"path"
)
const (
// 2^18 / 8 / 1 uses 256MB memory and approx 1s CPU time on a modern CPU.
scryptN = 1 << 18
scryptr = 8
scryptp = 1
scryptdkLen = 32
)
type keyStorePassphrase struct {
keysDirPath string
}
func NewKeyStorePassphrase(path string) KeyStore2 {
return &keyStorePassphrase{path}
}
func (ks keyStorePassphrase) GenerateNewKey(rand io.Reader, auth string) (key *Key, err error) {
return GenerateNewKeyDefault(ks, rand, auth)
}
func (ks keyStorePassphrase) GetKey(keyId *uuid.UUID, auth string) (key *Key, err error) {
keyBytes, err := DecryptKey(ks, keyId, auth)
if err != nil {
return nil, err
}
key = &Key{
Id: keyId,
PrivateKey: ToECDSA(keyBytes),
}
return key, err
}
func (ks keyStorePassphrase) StoreKey(key *Key, auth string) (err error) {
authArray := []byte(auth)
salt := getEntropyCSPRNG(32)
derivedKey, err := scrypt.Key(authArray, salt, scryptN, scryptr, scryptp, scryptdkLen)
if err != nil {
return err
}
keyBytes := FromECDSA(key.PrivateKey)
keyBytesHash := Sha3(keyBytes)
toEncrypt := PKCS7Pad(append(keyBytes, keyBytesHash...))
AES256Block, err := aes.NewCipher(derivedKey)
if err != nil {
return err
}
iv := getEntropyCSPRNG(aes.BlockSize) // 16
AES256CBCEncrypter := cipher.NewCBCEncrypter(AES256Block, iv)
cipherText := make([]byte, len(toEncrypt))
AES256CBCEncrypter.CryptBlocks(cipherText, toEncrypt)
cipherStruct := cipherJSON{
salt,
iv,
cipherText,
}
keyStruct := encryptedKeyJSON{
*key.Id,
cipherStruct,
}
keyJSON, err := json.Marshal(keyStruct)
if err != nil {
return err
}
return WriteKeyFile(key.Id.String(), ks.keysDirPath, keyJSON)
}
func (ks keyStorePassphrase) DeleteKey(keyId *uuid.UUID, auth string) (err error) {
// only delete if correct passphrase is given
_, err = DecryptKey(ks, keyId, auth)
if err != nil {
return err
}
keyDirPath := path.Join(ks.keysDirPath, keyId.String())
return os.RemoveAll(keyDirPath)
}
func DecryptKey(ks keyStorePassphrase, keyId *uuid.UUID, auth string) (keyBytes []byte, err error) {
fileContent, err := GetKeyFile(ks.keysDirPath, keyId)
if err != nil {
return nil, err
}
keyProtected := new(encryptedKeyJSON)
err = json.Unmarshal(fileContent, keyProtected)
salt := keyProtected.Crypto.Salt
iv := keyProtected.Crypto.IV
cipherText := keyProtected.Crypto.CipherText
authArray := []byte(auth)
derivedKey, err := scrypt.Key(authArray, salt, scryptN, scryptr, scryptp, scryptdkLen)
if err != nil {
return nil, err
}
AES256Block, err := aes.NewCipher(derivedKey)
if err != nil {
return nil, err
}
AES256CBCDecrypter := cipher.NewCBCDecrypter(AES256Block, iv)
paddedPlainText := make([]byte, len(cipherText))
AES256CBCDecrypter.CryptBlocks(paddedPlainText, cipherText)
plainText := PKCS7Unpad(paddedPlainText)
if plainText == nil {
err = errors.New("Decryption failed: PKCS7Unpad failed after decryption")
return nil, err
}
keyBytes = plainText[:len(plainText)-32]
keyBytesHash := plainText[len(plainText)-32:]
if !bytes.Equal(Sha3(keyBytes), keyBytesHash) {
err = errors.New("Decryption failed: checksum mismatch")
return nil, err
}
return keyBytes, err
}
func getEntropyCSPRNG(n int) []byte {
mainBuff := make([]byte, n)
_, err := io.ReadFull(crand.Reader, mainBuff)
if err != nil {
panic("key generation: reading from crypto/rand failed: " + err.Error())
}
return mainBuff
}
// From https://leanpub.com/gocrypto/read#leanpub-auto-block-cipher-modes
func PKCS7Pad(in []byte) []byte {
padding := 16 - (len(in) % 16)
if padding == 0 {
padding = 16
}
for i := 0; i < padding; i++ {
in = append(in, byte(padding))
}
return in
}
func PKCS7Unpad(in []byte) []byte {
if len(in) == 0 {
return nil
}
padding := in[len(in)-1]
if int(padding) > len(in) || padding > aes.BlockSize {
return nil
} else if padding == 0 {
return nil
}
for i := len(in) - 1; i > len(in)-int(padding)-1; i-- {
if in[i] != padding {
return nil
}
}
return in[:len(in)-int(padding)]
}

114
crypto/key_store_plain.go Normal file
View file

@ -0,0 +1,114 @@
/*
This file is part of go-ethereum
go-ethereum is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
go-ethereum is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
*/
/**
* @authors
* Gustav Simonsson <gustav.simonsson@gmail.com>
* @date 2015
*
*/
package crypto
import (
"code.google.com/p/go-uuid/uuid"
"encoding/json"
"fmt"
"io"
"io/ioutil"
"os"
"os/user"
"path"
)
// TODO: rename to KeyStore when replacing existing KeyStore
type KeyStore2 interface {
// create new key using io.Reader entropy source and optionally using auth string
GenerateNewKey(io.Reader, string) (*Key, error)
GetKey(*uuid.UUID, string) (*Key, error) // key from id and auth string
StoreKey(*Key, string) error // store key optionally using auth string
DeleteKey(*uuid.UUID, string) error // delete key by id and auth string
}
type keyStorePlain struct {
keysDirPath string
}
// TODO: copied from cmd/ethereum/flags.go
func DefaultDataDir() string {
usr, _ := user.Current()
return path.Join(usr.HomeDir, ".ethereum")
}
func NewKeyStorePlain(path string) KeyStore2 {
return &keyStorePlain{path}
}
func (ks keyStorePlain) GenerateNewKey(rand io.Reader, auth string) (key *Key, err error) {
return GenerateNewKeyDefault(ks, rand, auth)
}
func GenerateNewKeyDefault(ks KeyStore2, rand io.Reader, auth string) (key *Key, err error) {
defer func() {
if r := recover(); r != nil {
err = fmt.Errorf("GenerateNewKey error: %v", r)
}
}()
key = NewKey(rand)
err = ks.StoreKey(key, auth)
return key, err
}
func (ks keyStorePlain) GetKey(keyId *uuid.UUID, auth string) (key *Key, err error) {
fileContent, err := GetKeyFile(ks.keysDirPath, keyId)
if err != nil {
return nil, err
}
key = new(Key)
err = json.Unmarshal(fileContent, key)
return key, err
}
func (ks keyStorePlain) StoreKey(key *Key, auth string) (err error) {
keyJSON, err := json.Marshal(key)
if err != nil {
return err
}
err = WriteKeyFile(key.Id.String(), ks.keysDirPath, keyJSON)
return err
}
func (ks keyStorePlain) DeleteKey(keyId *uuid.UUID, auth string) (err error) {
keyDirPath := path.Join(ks.keysDirPath, keyId.String())
err = os.RemoveAll(keyDirPath)
return err
}
func GetKeyFile(keysDirPath string, keyId *uuid.UUID) (fileContent []byte, err error) {
id := keyId.String()
return ioutil.ReadFile(path.Join(keysDirPath, id, id))
}
func WriteKeyFile(id string, keysDirPath string, content []byte) (err error) {
keyDirPath := path.Join(keysDirPath, id)
keyFilePath := path.Join(keyDirPath, id)
err = os.MkdirAll(keyDirPath, 0700) // read, write and dir search for user
if err != nil {
return err
}
return ioutil.WriteFile(keyFilePath, content, 0600) // read, write for user
}

85
crypto/key_store_test.go Normal file
View file

@ -0,0 +1,85 @@
package crypto
import (
crand "crypto/rand"
"reflect"
"testing"
)
func TestKeyStorePlain(t *testing.T) {
ks := NewKeyStorePlain(DefaultDataDir())
pass := "" // not used but required by API
k1, err := ks.GenerateNewKey(crand.Reader, pass)
if err != nil {
t.Fatal(err)
}
k2 := new(Key)
k2, err = ks.GetKey(k1.Id, pass)
if err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(k1.Id, k2.Id) {
t.Fatal(err)
}
if !reflect.DeepEqual(k1.PrivateKey, k2.PrivateKey) {
t.Fatal(err)
}
err = ks.DeleteKey(k2.Id, pass)
if err != nil {
t.Fatal(err)
}
}
func TestKeyStorePassphrase(t *testing.T) {
ks := NewKeyStorePassphrase(DefaultDataDir())
pass := "foo"
k1, err := ks.GenerateNewKey(crand.Reader, pass)
if err != nil {
t.Fatal(err)
}
k2 := new(Key)
k2, err = ks.GetKey(k1.Id, pass)
if err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(k1.Id, k2.Id) {
t.Fatal(err)
}
if !reflect.DeepEqual(k1.PrivateKey, k2.PrivateKey) {
t.Fatal(err)
}
err = ks.DeleteKey(k2.Id, pass) // also to clean up created files
if err != nil {
t.Fatal(err)
}
}
func TestKeyStorePassphraseDecryptionFail(t *testing.T) {
ks := NewKeyStorePassphrase(DefaultDataDir())
pass := "foo"
k1, err := ks.GenerateNewKey(crand.Reader, pass)
if err != nil {
t.Fatal(err)
}
_, err = ks.GetKey(k1.Id, "bar") // wrong passphrase
if err == nil {
t.Fatal(err)
}
err = ks.DeleteKey(k1.Id, "bar") // wrong passphrase
if err == nil {
t.Fatal(err)
}
err = ks.DeleteKey(k1.Id, pass) // to clean up
if err != nil {
t.Fatal(err)
}
}

2
eth/backend.go
View file

@ -245,7 +245,7 @@ func (s *Ethereum) Start(seed bool) error {
if seed {
logger.Infof("Connect to seed node %v", seedNodeAddress)
if err := s.SuggestPeer(seedNodeAddress); err != nil {
return err
logger.Infoln(err)
}
}

4
p2p/server.go
View file

@ -333,7 +333,7 @@ func (srv *Server) dialLoop() {
case desc := <-suggest:
// candidate peer found, will dial out asyncronously
// if connection fails slot will be released
srvlog.Infof("dial %v (%v)", desc, *slot)
srvlog.DebugDetailf("dial %v (%v)", desc, *slot)
go srv.dialPeer(desc, *slot)
// we can watch if more peers needed in the next loop
slots = srv.peerSlots
@ -355,7 +355,7 @@ func (srv *Server) dialPeer(desc *peerAddr, slot int) {
srvlog.Debugf("Dialing %v (slot %d)\n", desc, slot)
conn, err := srv.Dialer.Dial(desc.Network(), desc.String())
if err != nil {
srvlog.Errorf("Dial error: %v", err)
srvlog.DebugDetailf("dial error: %v", err)
srv.peerSlots <- slot
return
}

5
vm/common.go
View file

@ -9,11 +9,10 @@ import (
var vmlogger = logger.NewLogger("VM")
type Type int
type Type byte
const (
StandardVmTy Type = iota
DebugVmTy
StdVmTy Type = iota
JitVmTy
MaxVmTy

965
vm/vm.go
View file

@ -1,38 +1,963 @@
package vm
import "math/big"
import (
"fmt"
"math/big"
// BIG FAT WARNING. THIS VM IS NOT YET IS USE!
// I want to get all VM tests pass first before updating this VM
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/ethutil"
"github.com/ethereum/go-ethereum/state"
)
type Vm struct {
env Environment
logTy byte
logStr string
err error
depth int
Dbg Debugger
BreakPoints []int64
Stepping bool
Fn string
Recoverable bool
}
func New(env Environment, typ Type) VirtualMachine {
switch typ {
case DebugVmTy:
return NewDebugVm(env)
case JitVmTy:
return NewJitVm(env)
func New(env Environment) *Vm {
lt := LogTyPretty
if ethutil.Config.Diff {
lt = LogTyDiff
}
return &Vm{env: env, logTy: lt, Recoverable: true}
}
func (self *Vm) Run(me, caller ContextRef, code []byte, value, gas, price *big.Int, callData []byte) (ret []byte, err error) {
self.env.SetDepth(self.env.Depth() + 1)
msg := self.env.State().Manifest().AddMessage(&state.Message{
To: me.Address(), From: caller.Address(),
Input: callData,
Origin: self.env.Origin(),
Timestamp: self.env.Time(), Coinbase: self.env.Coinbase(), Number: self.env.BlockNumber(),
Value: value,
})
context := NewContext(caller, me, code, gas, price)
vmlogger.Debugf("(%d) (%x) %x (code=%d) gas: %v (d) %x\n", self.env.Depth(), caller.Address()[:4], context.Address(), len(code), context.Gas, callData)
if self.Recoverable {
// Recover from any require exception
defer func() {
if r := recover(); r != nil {
self.Printf(" %v", r).Endl()
context.UseGas(context.Gas)
ret = context.Return(nil)
err = fmt.Errorf("%v", r)
}
}()
}
if p := Precompiled[string(me.Address())]; p != nil {
return self.RunPrecompiled(p, callData, context)
}
var (
op OpCode
destinations = analyseJumpDests(context.Code)
mem = NewMemory()
stack = NewStack()
pc uint64 = 0
step = 0
prevStep = 0
statedb = self.env.State()
jump = func(from uint64, to *big.Int) {
p := to.Uint64()
nop := context.GetOp(p)
if !destinations.Has(p) {
panic(fmt.Sprintf("invalid jump destination (%v) %v", nop, p))
}
self.Printf(" ~> %v", to)
pc = to.Uint64()
self.Endl()
}
)
// Don't bother with the execution if there's no code.
if len(code) == 0 {
return context.Return(nil), nil
}
for {
prevStep = step
// The base for all big integer arithmetic
base := new(big.Int)
step++
// Get the memory location of pc
op = context.GetOp(pc)
self.Printf("(pc) %-3d -o- %-14s (m) %-4d (s) %-4d ", pc, op.String(), mem.Len(), stack.Len())
if self.Dbg != nil {
//self.Dbg.Step(self, op, mem, stack, context)
}
newMemSize, gas := self.calculateGasAndSize(context, caller, op, statedb, mem, stack)
self.Printf("(g) %-3v (%v)", gas, context.Gas)
if !context.UseGas(gas) {
self.Endl()
tmp := new(big.Int).Set(context.Gas)
context.UseGas(context.Gas)
return context.Return(nil), OOG(gas, tmp)
}
mem.Resize(newMemSize.Uint64())
switch op {
// 0x20 range
case ADD:
x, y := stack.Popn()
self.Printf(" %v + %v", y, x)
base.Add(y, x)
U256(base)
self.Printf(" = %v", base)
// Pop result back on the stack
stack.Push(base)
case SUB:
x, y := stack.Popn()
self.Printf(" %v - %v", y, x)
base.Sub(y, x)
U256(base)
self.Printf(" = %v", base)
// Pop result back on the stack
stack.Push(base)
case MUL:
x, y := stack.Popn()
self.Printf(" %v * %v", y, x)
base.Mul(y, x)
U256(base)
self.Printf(" = %v", base)
// Pop result back on the stack
stack.Push(base)
case DIV:
x, y := stack.Pop(), stack.Pop()
self.Printf(" %v / %v", x, y)
if y.Cmp(ethutil.Big0) != 0 {
base.Div(x, y)
}
U256(base)
self.Printf(" = %v", base)
// Pop result back on the stack
stack.Push(base)
case SDIV:
x, y := S256(stack.Pop()), S256(stack.Pop())
self.Printf(" %v / %v", x, y)
if y.Cmp(ethutil.Big0) == 0 {
base.Set(ethutil.Big0)
} else {
n := new(big.Int)
if new(big.Int).Mul(x, y).Cmp(ethutil.Big0) < 0 {
n.SetInt64(-1)
} else {
n.SetInt64(1)
}
base.Div(x.Abs(x), y.Abs(y)).Mul(base, n)
U256(base)
}
self.Printf(" = %v", base)
stack.Push(base)
case MOD:
x, y := stack.Pop(), stack.Pop()
self.Printf(" %v %% %v", x, y)
if y.Cmp(ethutil.Big0) == 0 {
base.Set(ethutil.Big0)
} else {
base.Mod(x, y)
}
U256(base)
self.Printf(" = %v", base)
stack.Push(base)
case SMOD:
x, y := S256(stack.Pop()), S256(stack.Pop())
self.Printf(" %v %% %v", x, y)
if y.Cmp(ethutil.Big0) == 0 {
base.Set(ethutil.Big0)
} else {
n := new(big.Int)
if x.Cmp(ethutil.Big0) < 0 {
n.SetInt64(-1)
} else {
n.SetInt64(1)
}
base.Mod(x.Abs(x), y.Abs(y)).Mul(base, n)
U256(base)
}
self.Printf(" = %v", base)
stack.Push(base)
case EXP:
x, y := stack.Popn()
self.Printf(" %v ** %v", y, x)
base.Exp(y, x, Pow256)
U256(base)
self.Printf(" = %v", base)
stack.Push(base)
case SIGNEXTEND:
back := stack.Pop().Uint64()
if back < 31 {
bit := uint(back*8 + 7)
num := stack.Pop()
mask := new(big.Int).Lsh(ethutil.Big1, bit)
mask.Sub(mask, ethutil.Big1)
if ethutil.BitTest(num, int(bit)) {
num.Or(num, mask.Not(mask))
} else {
num.And(num, mask)
}
num = U256(num)
self.Printf(" = %v", num)
stack.Push(num)
}
case NOT:
base.Sub(Pow256, stack.Pop()).Sub(base, ethutil.Big1)
// Not needed
//base = U256(base)
stack.Push(base)
case LT:
x, y := stack.Popn()
self.Printf(" %v < %v", y, x)
// x < y
if y.Cmp(x) < 0 {
stack.Push(ethutil.BigTrue)
} else {
stack.Push(ethutil.BigFalse)
}
case GT:
x, y := stack.Popn()
self.Printf(" %v > %v", y, x)
// x > y
if y.Cmp(x) > 0 {
stack.Push(ethutil.BigTrue)
} else {
stack.Push(ethutil.BigFalse)
}
case SLT:
y, x := S256(stack.Pop()), S256(stack.Pop())
self.Printf(" %v < %v", y, x)
// x < y
if y.Cmp(S256(x)) < 0 {
stack.Push(ethutil.BigTrue)
} else {
stack.Push(ethutil.BigFalse)
}
case SGT:
y, x := S256(stack.Pop()), S256(stack.Pop())
self.Printf(" %v > %v", y, x)
// x > y
if y.Cmp(x) > 0 {
stack.Push(ethutil.BigTrue)
} else {
stack.Push(ethutil.BigFalse)
}
case EQ:
x, y := stack.Popn()
self.Printf(" %v == %v", y, x)
// x == y
if x.Cmp(y) == 0 {
stack.Push(ethutil.BigTrue)
} else {
stack.Push(ethutil.BigFalse)
}
case ISZERO:
x := stack.Pop()
if x.Cmp(ethutil.BigFalse) > 0 {
stack.Push(ethutil.BigFalse)
} else {
stack.Push(ethutil.BigTrue)
}
// 0x10 range
case AND:
x, y := stack.Popn()
self.Printf(" %v & %v", y, x)
stack.Push(base.And(y, x))
case OR:
x, y := stack.Popn()
self.Printf(" %v | %v", y, x)
stack.Push(base.Or(y, x))
case XOR:
x, y := stack.Popn()
self.Printf(" %v ^ %v", y, x)
stack.Push(base.Xor(y, x))
case BYTE:
val, th := stack.Popn()
if th.Cmp(big.NewInt(32)) < 0 {
byt := big.NewInt(int64(ethutil.LeftPadBytes(val.Bytes(), 32)[th.Int64()]))
base.Set(byt)
} else {
base.Set(ethutil.BigFalse)
}
self.Printf(" => 0x%x", base.Bytes())
stack.Push(base)
case ADDMOD:
x := stack.Pop()
y := stack.Pop()
z := stack.Pop()
add := new(big.Int).Add(x, y)
if len(z.Bytes()) > 0 { // NOT 0x0
base.Mod(add, z)
U256(base)
}
self.Printf(" %v + %v %% %v = %v", x, y, z, base)
stack.Push(base)
case MULMOD:
x := stack.Pop()
y := stack.Pop()
z := stack.Pop()
mul := new(big.Int).Mul(x, y)
if len(z.Bytes()) > 0 { // NOT 0x0
base.Mod(mul, z)
U256(base)
}
self.Printf(" %v + %v %% %v = %v", x, y, z, base)
stack.Push(base)
// 0x20 range
case SHA3:
size, offset := stack.Popn()
data := crypto.Sha3(mem.Get(offset.Int64(), size.Int64()))
stack.Push(ethutil.BigD(data))
self.Printf(" => %x", data)
// 0x30 range
case ADDRESS:
stack.Push(ethutil.BigD(context.Address()))
self.Printf(" => %x", context.Address())
case BALANCE:
addr := stack.Pop().Bytes()
balance := statedb.GetBalance(addr)
stack.Push(balance)
self.Printf(" => %v (%x)", balance, addr)
case ORIGIN:
origin := self.env.Origin()
stack.Push(ethutil.BigD(origin))
self.Printf(" => %x", origin)
case CALLER:
caller := context.caller.Address()
stack.Push(ethutil.BigD(caller))
self.Printf(" => %x", caller)
case CALLVALUE:
stack.Push(value)
self.Printf(" => %v", value)
case CALLDATALOAD:
var (
offset = stack.Pop()
data = make([]byte, 32)
lenData = big.NewInt(int64(len(callData)))
)
if lenData.Cmp(offset) >= 0 {
length := new(big.Int).Add(offset, ethutil.Big32)
length = ethutil.BigMin(length, lenData)
copy(data, callData[offset.Int64():length.Int64()])
}
self.Printf(" => 0x%x", data)
stack.Push(ethutil.BigD(data))
case CALLDATASIZE:
l := int64(len(callData))
stack.Push(big.NewInt(l))
self.Printf(" => %d", l)
case CALLDATACOPY:
var (
size = uint64(len(callData))
mOff = stack.Pop().Uint64()
cOff = stack.Pop().Uint64()
l = stack.Pop().Uint64()
)
if cOff > size {
cOff = 0
l = 0
} else if cOff+l > size {
l = 0
}
code := callData[cOff : cOff+l]
mem.Set(mOff, l, code)
self.Printf(" => [%v, %v, %v] %x", mOff, cOff, l, callData[cOff:cOff+l])
case CODESIZE, EXTCODESIZE:
var code []byte
if op == EXTCODESIZE {
addr := stack.Pop().Bytes()
code = statedb.GetCode(addr)
} else {
code = context.Code
}
l := big.NewInt(int64(len(code)))
stack.Push(l)
self.Printf(" => %d", l)
case CODECOPY, EXTCODECOPY:
var code []byte
if op == EXTCODECOPY {
code = statedb.GetCode(stack.Pop().Bytes())
} else {
code = context.Code
}
context := NewContext(nil, nil, code, ethutil.Big0, ethutil.Big0)
var (
mOff = stack.Pop().Uint64()
cOff = stack.Pop().Uint64()
l = stack.Pop().Uint64()
)
codeCopy := context.GetCode(cOff, l)
mem.Set(mOff, l, codeCopy)
self.Printf(" => [%v, %v, %v] %x", mOff, cOff, l, codeCopy)
case GASPRICE:
stack.Push(context.Price)
self.Printf(" => %v", context.Price)
// 0x40 range
case BLOCKHASH:
num := stack.Pop()
n := U256(new(big.Int).Sub(self.env.BlockNumber(), ethutil.Big257))
if num.Cmp(n) > 0 && num.Cmp(self.env.BlockNumber()) < 0 {
stack.Push(ethutil.BigD(self.env.GetHash(num.Uint64())))
} else {
stack.Push(ethutil.Big0)
}
self.Printf(" => 0x%x", stack.Peek().Bytes())
case COINBASE:
coinbase := self.env.Coinbase()
stack.Push(ethutil.BigD(coinbase))
self.Printf(" => 0x%x", coinbase)
case TIMESTAMP:
time := self.env.Time()
stack.Push(big.NewInt(time))
self.Printf(" => 0x%x", time)
case NUMBER:
number := self.env.BlockNumber()
stack.Push(number)
self.Printf(" => 0x%x", number.Bytes())
case DIFFICULTY:
difficulty := self.env.Difficulty()
stack.Push(difficulty)
self.Printf(" => 0x%x", difficulty.Bytes())
case GASLIMIT:
self.Printf(" => %v", self.env.GasLimit())
stack.Push(self.env.GasLimit())
// 0x50 range
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 := uint64(op - PUSH1 + 1)
byts := context.GetRangeValue(pc+1, a)
// Push value to stack
stack.Push(ethutil.BigD(byts))
pc += a
step += int(op) - int(PUSH1) + 1
self.Printf(" => 0x%x", byts)
case POP:
stack.Pop()
case DUP1, DUP2, DUP3, DUP4, DUP5, DUP6, DUP7, DUP8, DUP9, DUP10, DUP11, DUP12, DUP13, DUP14, DUP15, DUP16:
n := int(op - DUP1 + 1)
stack.Dupn(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:
n := int(op - SWAP1 + 2)
x, y := stack.Swapn(n)
self.Printf(" => [%d] %x [0] %x", n, x.Bytes(), y.Bytes())
case LOG0, LOG1, LOG2, LOG3, LOG4:
n := int(op - LOG0)
topics := make([][]byte, n)
mSize, mStart := stack.Popn()
for i := 0; i < n; i++ {
topics[i] = ethutil.LeftPadBytes(stack.Pop().Bytes(), 32)
}
data := mem.Get(mStart.Int64(), mSize.Int64())
log := &Log{context.Address(), topics, data}
self.env.AddLog(log)
self.Printf(" => %v", log)
case MLOAD:
offset := stack.Pop()
val := ethutil.BigD(mem.Get(offset.Int64(), 32))
stack.Push(val)
self.Printf(" => 0x%x", val.Bytes())
case MSTORE: // Store the value at stack top-1 in to memory at location stack top
// Pop value of the stack
val, mStart := stack.Popn()
mem.Set(mStart.Uint64(), 32, ethutil.BigToBytes(val, 256))
self.Printf(" => 0x%x", val)
case MSTORE8:
off := stack.Pop()
val := stack.Pop()
mem.store[off.Int64()] = byte(val.Int64() & 0xff)
self.Printf(" => [%v] 0x%x", off, val)
case SLOAD:
loc := stack.Pop()
val := ethutil.BigD(statedb.GetState(context.Address(), loc.Bytes()))
stack.Push(val)
self.Printf(" {0x%x : 0x%x}", loc.Bytes(), val.Bytes())
case SSTORE:
val, loc := stack.Popn()
statedb.SetState(context.Address(), loc.Bytes(), val)
msg.AddStorageChange(loc.Bytes())
self.Printf(" {0x%x : 0x%x}", loc.Bytes(), val.Bytes())
case JUMP:
jump(pc, stack.Pop())
continue
case JUMPI:
cond, pos := stack.Popn()
if cond.Cmp(ethutil.BigTrue) >= 0 {
jump(pc, pos)
continue
}
case JUMPDEST:
case PC:
stack.Push(big.NewInt(int64(pc)))
case MSIZE:
stack.Push(big.NewInt(int64(mem.Len())))
case GAS:
stack.Push(context.Gas)
// 0x60 range
case CREATE:
var (
value = stack.Pop()
size, offset = stack.Popn()
input = mem.Get(offset.Int64(), size.Int64())
gas = new(big.Int).Set(context.Gas)
addr []byte
)
context.UseGas(context.Gas)
ret, suberr, ref := self.env.Create(context, nil, input, gas, price, value)
if suberr != nil {
stack.Push(ethutil.BigFalse)
self.Printf(" (*) 0x0 %v", suberr)
} else {
// gas < len(ret) * CreateDataGas == NO_CODE
dataGas := big.NewInt(int64(len(ret)))
dataGas.Mul(dataGas, GasCreateByte)
if context.UseGas(dataGas) {
ref.SetCode(ret)
msg.Output = ret
}
addr = ref.Address()
stack.Push(ethutil.BigD(addr))
self.Printf(" (*) %x", addr)
}
// Debug hook
if self.Dbg != nil {
self.Dbg.SetCode(context.Code)
}
case CALL, CALLCODE:
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()
// Pop return size and offset
retSize, retOffset := stack.Popn()
// Get the arguments from the memory
args := mem.Get(inOffset.Int64(), inSize.Int64())
var (
ret []byte
err error
)
if op == CALLCODE {
ret, err = self.env.CallCode(context, addr.Bytes(), args, gas, price, value)
} else {
ret, err = self.env.Call(context, addr.Bytes(), args, gas, price, value)
}
if err != nil {
stack.Push(ethutil.BigFalse)
vmlogger.Debugln(err)
} else {
stack.Push(ethutil.BigTrue)
msg.Output = ret
mem.Set(retOffset.Uint64(), retSize.Uint64(), ret)
}
self.Printf("resume %x (%v)", context.Address(), context.Gas)
// Debug hook
if self.Dbg != nil {
self.Dbg.SetCode(context.Code)
}
case RETURN:
size, offset := stack.Popn()
ret := mem.Get(offset.Int64(), size.Int64())
self.Printf(" => [%v, %v] (%d) 0x%x", offset, size, len(ret), ret).Endl()
return context.Return(ret), nil
case SUICIDE:
receiver := statedb.GetOrNewStateObject(stack.Pop().Bytes())
balance := statedb.GetBalance(context.Address())
self.Printf(" => (%x) %v", receiver.Address()[:4], balance)
receiver.AddAmount(balance)
statedb.Delete(context.Address())
fallthrough
case STOP: // Stop the context
self.Endl()
return context.Return(nil), nil
default:
return &Vm{env: env}
vmlogger.Debugf("(pc) %-3v Invalid opcode %x\n", pc, op)
panic(fmt.Errorf("Invalid opcode %x", op))
}
pc++
self.Endl()
if self.Dbg != nil {
for _, instrNo := range self.Dbg.BreakPoints() {
if pc == uint64(instrNo) {
self.Stepping = true
if !self.Dbg.BreakHook(prevStep, op, mem, stack, statedb.GetStateObject(context.Address())) {
return nil, nil
}
} else if self.Stepping {
if !self.Dbg.StepHook(prevStep, op, mem, stack, statedb.GetStateObject(context.Address())) {
return nil, nil
}
}
}
}
}
}
func (self *Vm) Run(me, caller ContextRef, code []byte, value, gas, price *big.Int, data []byte) (ret []byte, err error) {
panic("not implemented")
func (self *Vm) calculateGasAndSize(context *Context, caller ContextRef, op OpCode, statedb *state.StateDB, mem *Memory, stack *Stack) (*big.Int, *big.Int) {
gas := new(big.Int)
addStepGasUsage := func(amount *big.Int) {
if amount.Cmp(ethutil.Big0) >= 0 {
gas.Add(gas, amount)
}
}
addStepGasUsage(GasStep)
var newMemSize *big.Int = ethutil.Big0
var additionalGas *big.Int = new(big.Int)
// Stack Check, memory resize & gas phase
switch op {
// Stack checks only
case ISZERO, CALLDATALOAD, POP, JUMP, NOT: // 1
stack.require(1)
case JUMPI, ADD, SUB, DIV, SDIV, MOD, SMOD, LT, GT, SLT, SGT, EQ, AND, OR, XOR, BYTE, SIGNEXTEND: // 2
stack.require(2)
case ADDMOD, MULMOD: // 3
stack.require(3)
case SWAP1, SWAP2, SWAP3, SWAP4, SWAP5, SWAP6, SWAP7, SWAP8, SWAP9, SWAP10, SWAP11, SWAP12, SWAP13, SWAP14, SWAP15, SWAP16:
n := int(op - SWAP1 + 2)
stack.require(n)
case DUP1, DUP2, DUP3, DUP4, DUP5, DUP6, DUP7, DUP8, DUP9, DUP10, DUP11, DUP12, DUP13, DUP14, DUP15, DUP16:
n := int(op - DUP1 + 1)
stack.require(n)
case LOG0, LOG1, LOG2, LOG3, LOG4:
n := int(op - LOG0)
stack.require(n + 2)
gas.Set(GasLog)
addStepGasUsage(new(big.Int).Mul(big.NewInt(int64(n)), GasLog))
mSize, mStart := stack.Peekn()
addStepGasUsage(mSize)
newMemSize = calcMemSize(mStart, mSize)
case EXP:
stack.require(2)
gas.Set(big.NewInt(int64(len(stack.data[stack.Len()-2].Bytes()) + 1)))
// Gas only
case STOP:
gas.Set(ethutil.Big0)
case SUICIDE:
stack.require(1)
gas.Set(ethutil.Big0)
case SLOAD:
stack.require(1)
gas.Set(GasSLoad)
// Memory resize & Gas
case SSTORE:
stack.require(2)
var mult *big.Int
y, x := stack.Peekn()
val := statedb.GetState(context.Address(), x.Bytes())
if len(val) == 0 && len(y.Bytes()) > 0 {
// 0 => non 0
mult = ethutil.Big3
} else if len(val) > 0 && len(y.Bytes()) == 0 {
statedb.Refund(caller.Address(), GasSStoreRefund)
mult = ethutil.Big0
} else {
// non 0 => non 0 (or 0 => 0)
mult = ethutil.Big1
}
gas.Set(new(big.Int).Mul(mult, GasSStore))
case BALANCE:
stack.require(1)
gas.Set(GasBalance)
case MSTORE:
stack.require(2)
newMemSize = calcMemSize(stack.Peek(), u256(32))
case MLOAD:
stack.require(1)
newMemSize = calcMemSize(stack.Peek(), u256(32))
case MSTORE8:
stack.require(2)
newMemSize = calcMemSize(stack.Peek(), u256(1))
case RETURN:
stack.require(2)
newMemSize = calcMemSize(stack.Peek(), stack.data[stack.Len()-2])
case SHA3:
stack.require(2)
gas.Set(GasSha)
newMemSize = calcMemSize(stack.Peek(), stack.data[stack.Len()-2])
additionalGas.Set(stack.data[stack.Len()-2])
case CALLDATACOPY:
stack.require(2)
newMemSize = calcMemSize(stack.Peek(), stack.data[stack.Len()-3])
additionalGas.Set(stack.data[stack.Len()-3])
case CODECOPY:
stack.require(3)
newMemSize = calcMemSize(stack.Peek(), stack.data[stack.Len()-3])
additionalGas.Set(stack.data[stack.Len()-3])
case EXTCODECOPY:
stack.require(4)
newMemSize = calcMemSize(stack.data[stack.Len()-2], stack.data[stack.Len()-4])
additionalGas.Set(stack.data[stack.Len()-4])
case CALL, CALLCODE:
stack.require(7)
gas.Set(GasCall)
addStepGasUsage(stack.data[stack.Len()-1])
x := calcMemSize(stack.data[stack.Len()-6], stack.data[stack.Len()-7])
y := calcMemSize(stack.data[stack.Len()-4], stack.data[stack.Len()-5])
newMemSize = ethutil.BigMax(x, y)
case CREATE:
stack.require(3)
gas.Set(GasCreate)
newMemSize = calcMemSize(stack.data[stack.Len()-2], stack.data[stack.Len()-3])
}
switch op {
case CALLDATACOPY, CODECOPY, EXTCODECOPY:
additionalGas.Add(additionalGas, u256(31))
additionalGas.Div(additionalGas, u256(32))
addStepGasUsage(additionalGas)
case SHA3:
additionalGas.Add(additionalGas, u256(31))
additionalGas.Div(additionalGas, u256(32))
additionalGas.Mul(additionalGas, GasSha3Byte)
addStepGasUsage(additionalGas)
}
if newMemSize.Cmp(ethutil.Big0) > 0 {
newMemSize.Add(newMemSize, u256(31))
newMemSize.Div(newMemSize, u256(32))
newMemSize.Mul(newMemSize, u256(32))
if newMemSize.Cmp(u256(int64(mem.Len()))) > 0 {
memGasUsage := new(big.Int).Sub(newMemSize, u256(int64(mem.Len())))
memGasUsage.Mul(GasMemory, memGasUsage)
memGasUsage.Div(memGasUsage, u256(32))
addStepGasUsage(memGasUsage)
}
}
return newMemSize, gas
}
func (self *Vm) RunPrecompiled(p *PrecompiledAccount, callData []byte, context *Context) (ret []byte, err error) {
gas := p.Gas(len(callData))
if context.UseGas(gas) {
ret = p.Call(callData)
self.Printf("NATIVE_FUNC => %x", ret)
self.Endl()
return context.Return(ret), nil
} else {
self.Printf("NATIVE_FUNC => failed").Endl()
tmp := new(big.Int).Set(context.Gas)
panic(OOG(gas, tmp).Error())
}
}
func (self *Vm) Printf(format string, v ...interface{}) VirtualMachine {
if self.logTy == LogTyPretty {
self.logStr += fmt.Sprintf(format, v...)
}
return self
}
func (self *Vm) Endl() VirtualMachine {
if self.logTy == LogTyPretty {
vmlogger.Debugln(self.logStr)
self.logStr = ""
}
return self
}
func (self *Vm) Env() Environment {
return self.env
}
func (self *Vm) Depth() int {
return self.depth
}
func (self *Vm) Printf(format string, v ...interface{}) VirtualMachine { return self }
func (self *Vm) Endl() VirtualMachine { return self }

961
vm/vm_debug.go
View file

@ -1,961 +0,0 @@
package vm
import (
"fmt"
"math/big"
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/ethutil"
"github.com/ethereum/go-ethereum/state"
)
type DebugVm struct {
env Environment
logTy byte
logStr string
err error
// Debugging
Dbg Debugger
BreakPoints []int64
Stepping bool
Fn string
Recoverable bool
}
func NewDebugVm(env Environment) *DebugVm {
lt := LogTyPretty
if ethutil.Config.Diff {
lt = LogTyDiff
}
return &DebugVm{env: env, logTy: lt, Recoverable: true}
}
func (self *DebugVm) Run(me, caller ContextRef, code []byte, value, gas, price *big.Int, callData []byte) (ret []byte, err error) {
self.env.SetDepth(self.env.Depth() + 1)
msg := self.env.State().Manifest().AddMessage(&state.Message{
To: me.Address(), From: caller.Address(),
Input: callData,
Origin: self.env.Origin(),
Timestamp: self.env.Time(), Coinbase: self.env.Coinbase(), Number: self.env.BlockNumber(),
Value: value,
})
context := NewContext(caller, me, code, gas, price)
vmlogger.Debugf("(%d) (%x) %x (code=%d) gas: %v (d) %x\n", self.env.Depth(), caller.Address()[:4], context.Address(), len(code), context.Gas, callData)
if self.Recoverable {
// Recover from any require exception
defer func() {
if r := recover(); r != nil {
self.Printf(" %v", r).Endl()
context.UseGas(context.Gas)
ret = context.Return(nil)
err = fmt.Errorf("%v", r)
}
}()
}
if p := Precompiled[string(me.Address())]; p != nil {
return self.RunPrecompiled(p, callData, context)
}
var (
op OpCode
destinations = analyseJumpDests(context.Code)
mem = NewMemory()
stack = NewStack()
pc uint64 = 0
step = 0
prevStep = 0
statedb = self.env.State()
jump = func(from uint64, to *big.Int) {
p := to.Uint64()
nop := context.GetOp(p)
if !destinations.Has(p) {
panic(fmt.Sprintf("invalid jump destination (%v) %v", nop, p))
}
self.Printf(" ~> %v", to)
pc = to.Uint64()
self.Endl()
}
)
// Don't bother with the execution if there's no code.
if len(code) == 0 {
return context.Return(nil), nil
}
for {
prevStep = step
// The base for all big integer arithmetic
base := new(big.Int)
step++
// Get the memory location of pc
op = context.GetOp(pc)
self.Printf("(pc) %-3d -o- %-14s (m) %-4d (s) %-4d ", pc, op.String(), mem.Len(), stack.Len())
newMemSize, gas := self.calculateGasAndSize(context, caller, op, statedb, mem, stack)
self.Printf("(g) %-3v (%v)", gas, context.Gas)
if !context.UseGas(gas) {
self.Endl()
tmp := new(big.Int).Set(context.Gas)
context.UseGas(context.Gas)
return context.Return(nil), OOG(gas, tmp)
}
mem.Resize(newMemSize.Uint64())
switch op {
// 0x20 range
case ADD:
x, y := stack.Popn()
self.Printf(" %v + %v", y, x)
base.Add(y, x)
U256(base)
self.Printf(" = %v", base)
// Pop result back on the stack
stack.Push(base)
case SUB:
x, y := stack.Popn()
self.Printf(" %v - %v", y, x)
base.Sub(y, x)
U256(base)
self.Printf(" = %v", base)
// Pop result back on the stack
stack.Push(base)
case MUL:
x, y := stack.Popn()
self.Printf(" %v * %v", y, x)
base.Mul(y, x)
U256(base)
self.Printf(" = %v", base)
// Pop result back on the stack
stack.Push(base)
case DIV:
x, y := stack.Pop(), stack.Pop()
self.Printf(" %v / %v", x, y)
if y.Cmp(ethutil.Big0) != 0 {
base.Div(x, y)
}
U256(base)
self.Printf(" = %v", base)
// Pop result back on the stack
stack.Push(base)
case SDIV:
x, y := S256(stack.Pop()), S256(stack.Pop())
self.Printf(" %v / %v", x, y)
if y.Cmp(ethutil.Big0) == 0 {
base.Set(ethutil.Big0)
} else {
n := new(big.Int)
if new(big.Int).Mul(x, y).Cmp(ethutil.Big0) < 0 {
n.SetInt64(-1)
} else {
n.SetInt64(1)
}
base.Div(x.Abs(x), y.Abs(y)).Mul(base, n)
U256(base)
}
self.Printf(" = %v", base)
stack.Push(base)
case MOD:
x, y := stack.Pop(), stack.Pop()
self.Printf(" %v %% %v", x, y)
if y.Cmp(ethutil.Big0) == 0 {
base.Set(ethutil.Big0)
} else {
base.Mod(x, y)
}
U256(base)
self.Printf(" = %v", base)
stack.Push(base)
case SMOD:
x, y := S256(stack.Pop()), S256(stack.Pop())
self.Printf(" %v %% %v", x, y)
if y.Cmp(ethutil.Big0) == 0 {
base.Set(ethutil.Big0)
} else {
n := new(big.Int)
if x.Cmp(ethutil.Big0) < 0 {
n.SetInt64(-1)
} else {
n.SetInt64(1)
}
base.Mod(x.Abs(x), y.Abs(y)).Mul(base, n)
U256(base)
}
self.Printf(" = %v", base)
stack.Push(base)
case EXP:
x, y := stack.Popn()
self.Printf(" %v ** %v", y, x)
base.Exp(y, x, Pow256)
U256(base)
self.Printf(" = %v", base)
stack.Push(base)
case SIGNEXTEND:
back := stack.Pop().Uint64()
if back < 31 {
bit := uint(back*8 + 7)
num := stack.Pop()
mask := new(big.Int).Lsh(ethutil.Big1, bit)
mask.Sub(mask, ethutil.Big1)
if ethutil.BitTest(num, int(bit)) {
num.Or(num, mask.Not(mask))
} else {
num.And(num, mask)
}
num = U256(num)
self.Printf(" = %v", num)
stack.Push(num)
}
case NOT:
base.Sub(Pow256, stack.Pop()).Sub(base, ethutil.Big1)
// Not needed
//base = U256(base)
stack.Push(base)
case LT:
x, y := stack.Popn()
self.Printf(" %v < %v", y, x)
// x < y
if y.Cmp(x) < 0 {
stack.Push(ethutil.BigTrue)
} else {
stack.Push(ethutil.BigFalse)
}
case GT:
x, y := stack.Popn()
self.Printf(" %v > %v", y, x)
// x > y
if y.Cmp(x) > 0 {
stack.Push(ethutil.BigTrue)
} else {
stack.Push(ethutil.BigFalse)
}
case SLT:
y, x := S256(stack.Pop()), S256(stack.Pop())
self.Printf(" %v < %v", y, x)
// x < y
if y.Cmp(S256(x)) < 0 {
stack.Push(ethutil.BigTrue)
} else {
stack.Push(ethutil.BigFalse)
}
case SGT:
y, x := S256(stack.Pop()), S256(stack.Pop())
self.Printf(" %v > %v", y, x)
// x > y
if y.Cmp(x) > 0 {
stack.Push(ethutil.BigTrue)
} else {
stack.Push(ethutil.BigFalse)
}
case EQ:
x, y := stack.Popn()
self.Printf(" %v == %v", y, x)
// x == y
if x.Cmp(y) == 0 {
stack.Push(ethutil.BigTrue)
} else {
stack.Push(ethutil.BigFalse)
}
case ISZERO:
x := stack.Pop()
if x.Cmp(ethutil.BigFalse) > 0 {
stack.Push(ethutil.BigFalse)
} else {
stack.Push(ethutil.BigTrue)
}
// 0x10 range
case AND:
x, y := stack.Popn()
self.Printf(" %v & %v", y, x)
stack.Push(base.And(y, x))
case OR:
x, y := stack.Popn()
self.Printf(" %v | %v", y, x)
stack.Push(base.Or(y, x))
case XOR:
x, y := stack.Popn()
self.Printf(" %v ^ %v", y, x)
stack.Push(base.Xor(y, x))
case BYTE:
val, th := stack.Popn()
if th.Cmp(big.NewInt(32)) < 0 {
byt := big.NewInt(int64(ethutil.LeftPadBytes(val.Bytes(), 32)[th.Int64()]))
base.Set(byt)
} else {
base.Set(ethutil.BigFalse)
}
self.Printf(" => 0x%x", base.Bytes())
stack.Push(base)
case ADDMOD:
x := stack.Pop()
y := stack.Pop()
z := stack.Pop()
add := new(big.Int).Add(x, y)
if len(z.Bytes()) > 0 { // NOT 0x0
base.Mod(add, z)
U256(base)
}
self.Printf(" %v + %v %% %v = %v", x, y, z, base)
stack.Push(base)
case MULMOD:
x := stack.Pop()
y := stack.Pop()
z := stack.Pop()
mul := new(big.Int).Mul(x, y)
if len(z.Bytes()) > 0 { // NOT 0x0
base.Mod(mul, z)
U256(base)
}
self.Printf(" %v + %v %% %v = %v", x, y, z, base)
stack.Push(base)
// 0x20 range
case SHA3:
size, offset := stack.Popn()
data := crypto.Sha3(mem.Get(offset.Int64(), size.Int64()))
stack.Push(ethutil.BigD(data))
self.Printf(" => %x", data)
// 0x30 range
case ADDRESS:
stack.Push(ethutil.BigD(context.Address()))
self.Printf(" => %x", context.Address())
case BALANCE:
addr := stack.Pop().Bytes()
balance := statedb.GetBalance(addr)
stack.Push(balance)
self.Printf(" => %v (%x)", balance, addr)
case ORIGIN:
origin := self.env.Origin()
stack.Push(ethutil.BigD(origin))
self.Printf(" => %x", origin)
case CALLER:
caller := context.caller.Address()
stack.Push(ethutil.BigD(caller))
self.Printf(" => %x", caller)
case CALLVALUE:
stack.Push(value)
self.Printf(" => %v", value)
case CALLDATALOAD:
var (
offset = stack.Pop()
data = make([]byte, 32)
lenData = big.NewInt(int64(len(callData)))
)
if lenData.Cmp(offset) >= 0 {
length := new(big.Int).Add(offset, ethutil.Big32)
length = ethutil.BigMin(length, lenData)
copy(data, callData[offset.Int64():length.Int64()])
}
self.Printf(" => 0x%x", data)
stack.Push(ethutil.BigD(data))
case CALLDATASIZE:
l := int64(len(callData))
stack.Push(big.NewInt(l))
self.Printf(" => %d", l)
case CALLDATACOPY:
var (
size = uint64(len(callData))
mOff = stack.Pop().Uint64()
cOff = stack.Pop().Uint64()
l = stack.Pop().Uint64()
)
if cOff > size {
cOff = 0
l = 0
} else if cOff+l > size {
l = 0
}
code := callData[cOff : cOff+l]
mem.Set(mOff, l, code)
self.Printf(" => [%v, %v, %v] %x", mOff, cOff, l, callData[cOff:cOff+l])
case CODESIZE, EXTCODESIZE:
var code []byte
if op == EXTCODESIZE {
addr := stack.Pop().Bytes()
code = statedb.GetCode(addr)
} else {
code = context.Code
}
l := big.NewInt(int64(len(code)))
stack.Push(l)
self.Printf(" => %d", l)
case CODECOPY, EXTCODECOPY:
var code []byte
if op == EXTCODECOPY {
code = statedb.GetCode(stack.Pop().Bytes())
} else {
code = context.Code
}
context := NewContext(nil, nil, code, ethutil.Big0, ethutil.Big0)
var (
mOff = stack.Pop().Uint64()
cOff = stack.Pop().Uint64()
l = stack.Pop().Uint64()
)
codeCopy := context.GetCode(cOff, l)
mem.Set(mOff, l, codeCopy)
self.Printf(" => [%v, %v, %v] %x", mOff, cOff, l, codeCopy)
case GASPRICE:
stack.Push(context.Price)
self.Printf(" => %v", context.Price)
// 0x40 range
case BLOCKHASH:
num := stack.Pop()
n := U256(new(big.Int).Sub(self.env.BlockNumber(), ethutil.Big257))
if num.Cmp(n) > 0 && num.Cmp(self.env.BlockNumber()) < 0 {
stack.Push(ethutil.BigD(self.env.GetHash(num.Uint64())))
} else {
stack.Push(ethutil.Big0)
}
self.Printf(" => 0x%x", stack.Peek().Bytes())
case COINBASE:
coinbase := self.env.Coinbase()
stack.Push(ethutil.BigD(coinbase))
self.Printf(" => 0x%x", coinbase)
case TIMESTAMP:
time := self.env.Time()
stack.Push(big.NewInt(time))
self.Printf(" => 0x%x", time)
case NUMBER:
number := self.env.BlockNumber()
stack.Push(number)
self.Printf(" => 0x%x", number.Bytes())
case DIFFICULTY:
difficulty := self.env.Difficulty()
stack.Push(difficulty)
self.Printf(" => 0x%x", difficulty.Bytes())
case GASLIMIT:
self.Printf(" => %v", self.env.GasLimit())
stack.Push(self.env.GasLimit())
// 0x50 range
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 := uint64(op - PUSH1 + 1)
byts := context.GetRangeValue(pc+1, a)
// Push value to stack
stack.Push(ethutil.BigD(byts))
pc += a
step += int(op) - int(PUSH1) + 1
self.Printf(" => 0x%x", byts)
case POP:
stack.Pop()
case DUP1, DUP2, DUP3, DUP4, DUP5, DUP6, DUP7, DUP8, DUP9, DUP10, DUP11, DUP12, DUP13, DUP14, DUP15, DUP16:
n := int(op - DUP1 + 1)
stack.Dupn(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:
n := int(op - SWAP1 + 2)
x, y := stack.Swapn(n)
self.Printf(" => [%d] %x [0] %x", n, x.Bytes(), y.Bytes())
case LOG0, LOG1, LOG2, LOG3, LOG4:
n := int(op - LOG0)
topics := make([][]byte, n)
mSize, mStart := stack.Popn()
for i := 0; i < n; i++ {
topics[i] = ethutil.LeftPadBytes(stack.Pop().Bytes(), 32)
}
data := mem.Get(mStart.Int64(), mSize.Int64())
log := &Log{context.Address(), topics, data}
self.env.AddLog(log)
self.Printf(" => %v", log)
case MLOAD:
offset := stack.Pop()
val := ethutil.BigD(mem.Get(offset.Int64(), 32))
stack.Push(val)
self.Printf(" => 0x%x", val.Bytes())
case MSTORE: // Store the value at stack top-1 in to memory at location stack top
// Pop value of the stack
val, mStart := stack.Popn()
mem.Set(mStart.Uint64(), 32, ethutil.BigToBytes(val, 256))
self.Printf(" => 0x%x", val)
case MSTORE8:
off := stack.Pop()
val := stack.Pop()
mem.store[off.Int64()] = byte(val.Int64() & 0xff)
self.Printf(" => [%v] 0x%x", off, val)
case SLOAD:
loc := stack.Pop()
val := ethutil.BigD(statedb.GetState(context.Address(), loc.Bytes()))
stack.Push(val)
self.Printf(" {0x%x : 0x%x}", loc.Bytes(), val.Bytes())
case SSTORE:
val, loc := stack.Popn()
statedb.SetState(context.Address(), loc.Bytes(), val)
msg.AddStorageChange(loc.Bytes())
self.Printf(" {0x%x : 0x%x}", loc.Bytes(), val.Bytes())
case JUMP:
jump(pc, stack.Pop())
continue
case JUMPI:
cond, pos := stack.Popn()
if cond.Cmp(ethutil.BigTrue) >= 0 {
jump(pc, pos)
continue
}
case JUMPDEST:
case PC:
stack.Push(big.NewInt(int64(pc)))
case MSIZE:
stack.Push(big.NewInt(int64(mem.Len())))
case GAS:
stack.Push(context.Gas)
// 0x60 range
case CREATE:
var (
value = stack.Pop()
size, offset = stack.Popn()
input = mem.Get(offset.Int64(), size.Int64())
gas = new(big.Int).Set(context.Gas)
addr []byte
)
context.UseGas(context.Gas)
ret, suberr, ref := self.env.Create(context, nil, input, gas, price, value)
if suberr != nil {
stack.Push(ethutil.BigFalse)
self.Printf(" (*) 0x0 %v", suberr)
} else {
// gas < len(ret) * CreateDataGas == NO_CODE
dataGas := big.NewInt(int64(len(ret)))
dataGas.Mul(dataGas, GasCreateByte)
if context.UseGas(dataGas) {
ref.SetCode(ret)
msg.Output = ret
}
addr = ref.Address()
stack.Push(ethutil.BigD(addr))
self.Printf(" (*) %x", addr)
}
// Debug hook
if self.Dbg != nil {
self.Dbg.SetCode(context.Code)
}
case CALL, CALLCODE:
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()
// Pop return size and offset
retSize, retOffset := stack.Popn()
// Get the arguments from the memory
args := mem.Get(inOffset.Int64(), inSize.Int64())
var (
ret []byte
err error
)
if op == CALLCODE {
ret, err = self.env.CallCode(context, addr.Bytes(), args, gas, price, value)
} else {
ret, err = self.env.Call(context, addr.Bytes(), args, gas, price, value)
}
if err != nil {
stack.Push(ethutil.BigFalse)
vmlogger.Debugln(err)
} else {
stack.Push(ethutil.BigTrue)
msg.Output = ret
mem.Set(retOffset.Uint64(), retSize.Uint64(), ret)
}
self.Printf("resume %x (%v)", context.Address(), context.Gas)
// Debug hook
if self.Dbg != nil {
self.Dbg.SetCode(context.Code)
}
case RETURN:
size, offset := stack.Popn()
ret := mem.Get(offset.Int64(), size.Int64())
self.Printf(" => [%v, %v] (%d) 0x%x", offset, size, len(ret), ret).Endl()
return context.Return(ret), nil
case SUICIDE:
receiver := statedb.GetOrNewStateObject(stack.Pop().Bytes())
balance := statedb.GetBalance(context.Address())
self.Printf(" => (%x) %v", receiver.Address()[:4], balance)
receiver.AddAmount(balance)
statedb.Delete(context.Address())
fallthrough
case STOP: // Stop the context
self.Endl()
return context.Return(nil), nil
default:
vmlogger.Debugf("(pc) %-3v Invalid opcode %x\n", pc, op)
panic(fmt.Errorf("Invalid opcode %x", op))
}
pc++
self.Endl()
if self.Dbg != nil {
for _, instrNo := range self.Dbg.BreakPoints() {
if pc == uint64(instrNo) {
self.Stepping = true
if !self.Dbg.BreakHook(prevStep, op, mem, stack, statedb.GetStateObject(context.Address())) {
return nil, nil
}
} else if self.Stepping {
if !self.Dbg.StepHook(prevStep, op, mem, stack, statedb.GetStateObject(context.Address())) {
return nil, nil
}
}
}
}
}
}
func (self *DebugVm) calculateGasAndSize(context *Context, caller ContextRef, op OpCode, statedb *state.StateDB, mem *Memory, stack *Stack) (*big.Int, *big.Int) {
gas := new(big.Int)
addStepGasUsage := func(amount *big.Int) {
if amount.Cmp(ethutil.Big0) >= 0 {
gas.Add(gas, amount)
}
}
addStepGasUsage(GasStep)
var newMemSize *big.Int = ethutil.Big0
var additionalGas *big.Int = new(big.Int)
// Stack Check, memory resize & gas phase
switch op {
// Stack checks only
case ISZERO, CALLDATALOAD, POP, JUMP, NOT: // 1
stack.require(1)
case JUMPI, ADD, SUB, DIV, SDIV, MOD, SMOD, LT, GT, SLT, SGT, EQ, AND, OR, XOR, BYTE, SIGNEXTEND: // 2
stack.require(2)
case ADDMOD, MULMOD: // 3
stack.require(3)
case SWAP1, SWAP2, SWAP3, SWAP4, SWAP5, SWAP6, SWAP7, SWAP8, SWAP9, SWAP10, SWAP11, SWAP12, SWAP13, SWAP14, SWAP15, SWAP16:
n := int(op - SWAP1 + 2)
stack.require(n)
case DUP1, DUP2, DUP3, DUP4, DUP5, DUP6, DUP7, DUP8, DUP9, DUP10, DUP11, DUP12, DUP13, DUP14, DUP15, DUP16:
n := int(op - DUP1 + 1)
stack.require(n)
case LOG0, LOG1, LOG2, LOG3, LOG4:
n := int(op - LOG0)
stack.require(n + 2)
gas.Set(GasLog)
addStepGasUsage(new(big.Int).Mul(big.NewInt(int64(n)), GasLog))
mSize, mStart := stack.Peekn()
addStepGasUsage(mSize)
newMemSize = calcMemSize(mStart, mSize)
case EXP:
stack.require(2)
gas.Set(big.NewInt(int64(len(stack.data[stack.Len()-2].Bytes()) + 1)))
// Gas only
case STOP:
gas.Set(ethutil.Big0)
case SUICIDE:
stack.require(1)
gas.Set(ethutil.Big0)
case SLOAD:
stack.require(1)
gas.Set(GasSLoad)
// Memory resize & Gas
case SSTORE:
stack.require(2)
var mult *big.Int
y, x := stack.Peekn()
val := statedb.GetState(context.Address(), x.Bytes())
if len(val) == 0 && len(y.Bytes()) > 0 {
// 0 => non 0
mult = ethutil.Big3
} else if len(val) > 0 && len(y.Bytes()) == 0 {
statedb.Refund(caller.Address(), GasSStoreRefund)
mult = ethutil.Big0
} else {
// non 0 => non 0 (or 0 => 0)
mult = ethutil.Big1
}
gas.Set(new(big.Int).Mul(mult, GasSStore))
case BALANCE:
stack.require(1)
gas.Set(GasBalance)
case MSTORE:
stack.require(2)
newMemSize = calcMemSize(stack.Peek(), u256(32))
case MLOAD:
stack.require(1)
newMemSize = calcMemSize(stack.Peek(), u256(32))
case MSTORE8:
stack.require(2)
newMemSize = calcMemSize(stack.Peek(), u256(1))
case RETURN:
stack.require(2)
newMemSize = calcMemSize(stack.Peek(), stack.data[stack.Len()-2])
case SHA3:
stack.require(2)
gas.Set(GasSha)
newMemSize = calcMemSize(stack.Peek(), stack.data[stack.Len()-2])
additionalGas.Set(stack.data[stack.Len()-2])
case CALLDATACOPY:
stack.require(2)
newMemSize = calcMemSize(stack.Peek(), stack.data[stack.Len()-3])
additionalGas.Set(stack.data[stack.Len()-3])
case CODECOPY:
stack.require(3)
newMemSize = calcMemSize(stack.Peek(), stack.data[stack.Len()-3])
additionalGas.Set(stack.data[stack.Len()-3])
case EXTCODECOPY:
stack.require(4)
newMemSize = calcMemSize(stack.data[stack.Len()-2], stack.data[stack.Len()-4])
additionalGas.Set(stack.data[stack.Len()-4])
case CALL, CALLCODE:
stack.require(7)
gas.Set(GasCall)
addStepGasUsage(stack.data[stack.Len()-1])
x := calcMemSize(stack.data[stack.Len()-6], stack.data[stack.Len()-7])
y := calcMemSize(stack.data[stack.Len()-4], stack.data[stack.Len()-5])
newMemSize = ethutil.BigMax(x, y)
case CREATE:
stack.require(3)
gas.Set(GasCreate)
newMemSize = calcMemSize(stack.data[stack.Len()-2], stack.data[stack.Len()-3])
}
switch op {
case CALLDATACOPY, CODECOPY, EXTCODECOPY:
additionalGas.Add(additionalGas, u256(31))
additionalGas.Div(additionalGas, u256(32))
addStepGasUsage(additionalGas)
case SHA3:
additionalGas.Add(additionalGas, u256(31))
additionalGas.Div(additionalGas, u256(32))
additionalGas.Mul(additionalGas, GasSha3Byte)
addStepGasUsage(additionalGas)
}
if newMemSize.Cmp(ethutil.Big0) > 0 {
newMemSize.Add(newMemSize, u256(31))
newMemSize.Div(newMemSize, u256(32))
newMemSize.Mul(newMemSize, u256(32))
if newMemSize.Cmp(u256(int64(mem.Len()))) > 0 {
memGasUsage := new(big.Int).Sub(newMemSize, u256(int64(mem.Len())))
memGasUsage.Mul(GasMemory, memGasUsage)
memGasUsage.Div(memGasUsage, u256(32))
addStepGasUsage(memGasUsage)
}
}
return newMemSize, gas
}
func (self *DebugVm) RunPrecompiled(p *PrecompiledAccount, callData []byte, context *Context) (ret []byte, err error) {
gas := p.Gas(len(callData))
if context.UseGas(gas) {
ret = p.Call(callData)
self.Printf("NATIVE_FUNC => %x", ret)
self.Endl()
return context.Return(ret), nil
} else {
self.Printf("NATIVE_FUNC => failed").Endl()
tmp := new(big.Int).Set(context.Gas)
panic(OOG(gas, tmp).Error())
}
}
func (self *DebugVm) Printf(format string, v ...interface{}) VirtualMachine {
if self.logTy == LogTyPretty {
self.logStr += fmt.Sprintf(format, v...)
}
return self
}
func (self *DebugVm) Endl() VirtualMachine {
if self.logTy == LogTyPretty {
vmlogger.Debugln(self.logStr)
self.logStr = ""
}
return self
}
func (self *DebugVm) Env() Environment {
return self.env
}

2
vm/vm_jit_fake.go
View file

@ -6,5 +6,5 @@ import "fmt"
func NewJitVm(env Environment) VirtualMachine {
fmt.Printf("Warning! EVM JIT not enabled.\n")
return NewDebugVm(env)
return New(env)
}

9
whisper/whisper_test.go
View file

@ -6,15 +6,6 @@ import (
"time"
)
func TestKeyManagement(t *testing.T) {
whisper := New()
key := whisper.NewIdentity()
if !whisper.HasIdentity(key) {
t.Error("expected whisper to have identify")
}
}
func TestEvent(t *testing.T) {
res := make(chan *Message, 1)
whisper := New()