diff --git a/.gitignore b/.gitignore
index de3a847ace5001c560b8164f6cdff8bf52fc441e..64dff7dd2140eaf0a94adb1f76286cae3cb03e94 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,6 +9,3 @@
*un~
.DS_Store
*/**/.DS_Store
-ethereum/ethereum
-ethereal/ethereal
-
diff --git a/.travis.yml b/.travis.yml
index 32740f91a55dd9da9097ade675299b3b76d0ca8c..3dcaa040b3e499aeb8e3dfa5ab4233ec335784f3 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,4 +1,4 @@
before_install: sudo apt-get install libgmp3-dev
language: go
go:
- - 1.2
+ - 1.3
diff --git a/LICENSE b/LICENSE
index 78efdaabe9d71de384bda09447903e48f54f685d..30f629158e68dd05be52829afa053bd006265d75 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,16 +1,16 @@
Copyright (c) 2013-2014, Jeffrey Wilcke. All rights reserved.
This library is free software; you can redistribute it and/or
-modify it under the terms of the GNU General Public
+modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library 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.
+Lesser General Public License for more details.
-You should have received a copy of the GNU General Public License
-along with this library; if not, write to the Free Software
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
MA 02110-1301 USA
diff --git a/README.md b/README.md
index 3d4a757973b68445120fd69233782c02e6f977c5..fd60f7a6a715ec7d8a42d4e1bdb1e85ad199f0da 100644
--- a/README.md
+++ b/README.md
@@ -10,7 +10,34 @@ Ethereum Go Client © 2014 Jeffrey Wilcke.
Current state: Proof of Concept 0.6.7.
-For the development package please see the [eth-go package](https://github.com/ethereum/eth-go).
+Ethereum is currently in its testing phase.
+For build instructions see the [Wiki](https://github.com/ethereum/go-ethereum/wiki/Building-Ethereum(Go)).
+
+Ethereum Go is split up in several sub packages Please refer to each
+individual package for more information.
+ 1. [eth](https://github.com/ethereum/go-ethereum)
+ 2. [ethchain](https://github.com/ethereum/go-ethereum/tree/master/ethchain)
+ 3. [ethwire](https://github.com/ethereum/go-ethereum/tree/master/ethwire)
+ 4. [ethdb](https://github.com/ethereum/go-ethereum/tree/master/ethdb)
+ 5. [ethutil](https://github.com/ethereum/go-ethereum/tree/master/ethutil)
+ 6. [ethpipe](https://github.com/ethereum/go-ethereum/tree/master/ethpipe)
+ 7. [ethvm](https://github.com/ethereum/go-ethereum/tree/master/ethvm)
+ 8. [ethtrie](https://github.com/ethereum/go-ethereum/tree/master/ethtrie)
+ 9. [ethreact](https://github.com/ethereum/go-ethereum/tree/master/ethreact)
+ 10. [ethlog](https://github.com/ethereum/go-ethereum/tree/master/ethlog)
+
+The [eth](https://github.com/ethereum/go-ethereum) is the top-level package
+of the Ethereum protocol. It functions as the Ethereum bootstrapping and
+peer communication layer. The [ethchain](https://github.com/ethereum/go-ethereum/tree/master/ethchain)
+contains the Ethereum blockchain, block manager, transaction and
+transaction handlers. The [ethwire](https://github.com/ethereum/go-ethereum/tree/master/ethwire) contains
+the Ethereum [wire protocol](http://wiki.ethereum.org/index.php/Wire_Protocol) which can be used
+to hook in to the Ethereum network. [ethutil](https://github.com/ethereum/go-ethereum/tree/master/ethutil) contains
+utility functions which are not Ethereum specific. The utility package
+contains the [patricia trie](http://wiki.ethereum.org/index.php/Patricia_Tree),
+[RLP Encoding](http://wiki.ethereum.org/index.php/RLP) and hex encoding
+helpers. The [ethdb](https://github.com/ethereum/go-ethereum/tree/master/ethdb) package
+contains the LevelDB interface and memory DB interface.
Build
=======
@@ -54,24 +81,26 @@ Mist only
Contribution
============
-If you would like to contribute to Ethereum Go, please fork, fix, commit and
-send a pull request to the main repository. Commits which do not comply with the coding standards explained below
-will be ignored. If you send a pull request, make sure that you
-commit to the `develop` branch and that you do not merge to `master`.
-Commits that are directly based off of the `master` branch instead of the `develop` branch will be ignored.
+If you'd like to contribute to Ethereum please fork, fix, commit and
+send a pull request. Commits who do not comply with the coding standards
+are ignored (use gofmt!). If you send pull requests make absolute sure that you
+commit on the `develop` branch and that you do not merge to master.
+Commits that are directly based on master are simply ignored.
-To make this process simpler try following the [git flow](http://nvie.com/posts/a-successful-git-branching-model/) branching model, as it sets this process up and streamlines work flow.
+To make life easier try [git flow](http://nvie.com/posts/a-successful-git-branching-model/) it sets
+this all up and streamlines your work flow.
Coding standards
================
-Code should be formatted according to the [Go Formatting
+Sources should be formatted according to the [Go Formatting
Style](http://golang.org/doc/effective_go.html#formatting).
-Unless struct fields are supposed to be directly accessible, provide
-getters and hide the fields through Go's exporting facility.
+Unless structs fields are supposed to be directly accesible, provide
+Getters and hide the fields through Go's exporting facility.
-Make comments in your code meaningful and only use them when necessary. Describe in detail what your code is trying to achieve. For example, this would be redundant and unnecessary commenting:
+When you comment put meaningfull comments. Describe in detail what you
+want to achieve.
*wrong*
@@ -82,7 +111,12 @@ if x > y {
}
```
-Everyone reading the source code should know what this code snippet was meant to achieve, and so those are **not** meaningful comments.
+Everyone reading the source probably know what you wanted to achieve
+with above code. Those are **not** meaningful comments.
-While this project is constantly tested and run, code tests should be written regardless. There is not time to evaluate every person's code specifically, so it is expected of you to write tests for the code so that it does not have to be tested manually. In fact, contributing by simply writing tests is perfectly fine!
+While the project isn't 100% tested I want you to write tests non the
+less. I haven't got time to evaluate everyone's code in detail so I
+expect you to write tests for me so I don't have to test your code
+manually. (If you want to contribute by just writing tests that's fine
+too!)
diff --git a/block_pool.go b/block_pool.go
new file mode 100644
index 0000000000000000000000000000000000000000..f65d9d5765cc35ef7fe0d24c9f3eec5eaa9ba3c5
--- /dev/null
+++ b/block_pool.go
@@ -0,0 +1,340 @@
+package eth
+
+import (
+ "bytes"
+ "container/list"
+ "fmt"
+ "math"
+ "math/big"
+ "sync"
+ "time"
+
+ "github.com/ethereum/go-ethereum/ethchain"
+ "github.com/ethereum/go-ethereum/ethlog"
+ "github.com/ethereum/go-ethereum/ethutil"
+ "github.com/ethereum/go-ethereum/ethwire"
+)
+
+var poollogger = ethlog.NewLogger("BPOOL")
+
+type block struct {
+ from *Peer
+ peer *Peer
+ block *ethchain.Block
+ reqAt time.Time
+ requested int
+}
+
+type BlockPool struct {
+ mut sync.Mutex
+
+ eth *Ethereum
+
+ hashes [][]byte
+ pool map[string]*block
+
+ td *big.Int
+ quit chan bool
+
+ fetchingHashes bool
+ downloadStartedAt time.Time
+
+ ChainLength, BlocksProcessed int
+
+ peer *Peer
+}
+
+func NewBlockPool(eth *Ethereum) *BlockPool {
+ return &BlockPool{
+ eth: eth,
+ pool: make(map[string]*block),
+ td: ethutil.Big0,
+ quit: make(chan bool),
+ }
+}
+
+func (self *BlockPool) Len() int {
+ return len(self.hashes)
+}
+
+func (self *BlockPool) Reset() {
+ self.pool = make(map[string]*block)
+ self.hashes = nil
+}
+
+func (self *BlockPool) HasLatestHash() bool {
+ self.mut.Lock()
+ defer self.mut.Unlock()
+
+ return self.pool[string(self.eth.ChainManager().CurrentBlock.Hash())] != nil
+}
+
+func (self *BlockPool) HasCommonHash(hash []byte) bool {
+ return self.eth.ChainManager().GetBlock(hash) != nil
+}
+
+func (self *BlockPool) Blocks() (blocks ethchain.Blocks) {
+ for _, item := range self.pool {
+ if item.block != nil {
+ blocks = append(blocks, item.block)
+ }
+ }
+
+ return
+}
+
+func (self *BlockPool) FetchHashes(peer *Peer) bool {
+ highestTd := self.eth.HighestTDPeer()
+
+ if (self.peer == nil && peer.td.Cmp(highestTd) >= 0) || (self.peer != nil && peer.td.Cmp(self.peer.td) > 0) || self.peer == peer {
+ if self.peer != peer {
+ poollogger.Debugf("Found better suitable peer (%v vs %v)\n", self.td, peer.td)
+
+ if self.peer != nil {
+ self.peer.doneFetchingHashes = true
+ }
+ }
+
+ self.peer = peer
+ self.td = peer.td
+
+ if !self.HasLatestHash() {
+ peer.doneFetchingHashes = false
+
+ const amount = 256
+ peerlogger.Debugf("Fetching hashes (%d) %x...\n", amount, peer.lastReceivedHash[0:4])
+ peer.QueueMessage(ethwire.NewMessage(ethwire.MsgGetBlockHashesTy, []interface{}{peer.lastReceivedHash, uint32(amount)}))
+ }
+
+ return true
+ }
+
+ return false
+}
+
+func (self *BlockPool) AddHash(hash []byte, peer *Peer) {
+ self.mut.Lock()
+ defer self.mut.Unlock()
+
+ if self.pool[string(hash)] == nil {
+ self.pool[string(hash)] = &block{peer, nil, nil, time.Now(), 0}
+
+ self.hashes = append([][]byte{hash}, self.hashes...)
+ }
+}
+
+func (self *BlockPool) Add(b *ethchain.Block, peer *Peer) {
+ self.addBlock(b, peer, false)
+}
+
+func (self *BlockPool) AddNew(b *ethchain.Block, peer *Peer) {
+ self.addBlock(b, peer, true)
+}
+
+func (self *BlockPool) addBlock(b *ethchain.Block, peer *Peer, newBlock bool) {
+ self.mut.Lock()
+ defer self.mut.Unlock()
+
+ hash := string(b.Hash())
+
+ if self.pool[hash] == nil && !self.eth.ChainManager().HasBlock(b.Hash()) {
+ poollogger.Infof("Got unrequested block (%x...)\n", hash[0:4])
+
+ self.hashes = append(self.hashes, b.Hash())
+ self.pool[hash] = &block{peer, peer, b, time.Now(), 0}
+
+ // The following is only performed on an unrequested new block
+ if newBlock {
+ fmt.Println("1.", !self.eth.ChainManager().HasBlock(b.PrevHash), ethutil.Bytes2Hex(b.Hash()[0:4]), ethutil.Bytes2Hex(b.PrevHash[0:4]))
+ fmt.Println("2.", self.pool[string(b.PrevHash)] == nil)
+ fmt.Println("3.", !self.fetchingHashes)
+ if !self.eth.ChainManager().HasBlock(b.PrevHash) && self.pool[string(b.PrevHash)] == nil && !self.fetchingHashes {
+ poollogger.Infof("Unknown chain, requesting (%x...)\n", b.PrevHash[0:4])
+ peer.QueueMessage(ethwire.NewMessage(ethwire.MsgGetBlockHashesTy, []interface{}{b.Hash(), uint32(256)}))
+ }
+ }
+ } else if self.pool[hash] != nil {
+ self.pool[hash].block = b
+ }
+
+ self.BlocksProcessed++
+}
+
+func (self *BlockPool) Remove(hash []byte) {
+ self.mut.Lock()
+ defer self.mut.Unlock()
+
+ self.hashes = ethutil.DeleteFromByteSlice(self.hashes, hash)
+ delete(self.pool, string(hash))
+}
+
+func (self *BlockPool) DistributeHashes() {
+ self.mut.Lock()
+ defer self.mut.Unlock()
+
+ var (
+ peerLen = self.eth.peers.Len()
+ amount = 256 * peerLen
+ dist = make(map[*Peer][][]byte)
+ )
+
+ num := int(math.Min(float64(amount), float64(len(self.pool))))
+ for i, j := 0, 0; i < len(self.hashes) && j < num; i++ {
+ hash := self.hashes[i]
+ item := self.pool[string(hash)]
+
+ if item != nil && item.block == nil {
+ var peer *Peer
+ lastFetchFailed := time.Since(item.reqAt) > 5*time.Second
+
+ // Handle failed requests
+ if lastFetchFailed && item.requested > 5 && item.peer != nil {
+ if item.requested < 100 {
+ // Select peer the hash was retrieved off
+ peer = item.from
+ } else {
+ // Remove it
+ self.hashes = ethutil.DeleteFromByteSlice(self.hashes, hash)
+ delete(self.pool, string(hash))
+ }
+ } else if lastFetchFailed || item.peer == nil {
+ // Find a suitable, available peer
+ eachPeer(self.eth.peers, func(p *Peer, v *list.Element) {
+ if peer == nil && len(dist[p]) < amount/peerLen {
+ peer = p
+ }
+ })
+ }
+
+ if peer != nil {
+ item.reqAt = time.Now()
+ item.peer = peer
+ item.requested++
+
+ dist[peer] = append(dist[peer], hash)
+ }
+ }
+ }
+
+ for peer, hashes := range dist {
+ peer.FetchBlocks(hashes)
+ }
+
+ if len(dist) > 0 {
+ self.downloadStartedAt = time.Now()
+ }
+}
+
+func (self *BlockPool) Start() {
+ go self.downloadThread()
+ go self.chainThread()
+}
+
+func (self *BlockPool) Stop() {
+ close(self.quit)
+}
+
+func (self *BlockPool) downloadThread() {
+ serviceTimer := time.NewTicker(100 * time.Millisecond)
+out:
+ for {
+ select {
+ case <-self.quit:
+ break out
+ case <-serviceTimer.C:
+ // Check if we're catching up. If not distribute the hashes to
+ // the peers and download the blockchain
+ self.fetchingHashes = false
+ eachPeer(self.eth.peers, func(p *Peer, v *list.Element) {
+ if p.statusKnown && p.FetchingHashes() {
+ self.fetchingHashes = true
+ }
+ })
+
+ if len(self.hashes) > 0 {
+ self.DistributeHashes()
+ }
+
+ if self.ChainLength < len(self.hashes) {
+ self.ChainLength = len(self.hashes)
+ }
+
+ /*
+ if !self.fetchingHashes {
+ blocks := self.Blocks()
+ ethchain.BlockBy(ethchain.Number).Sort(blocks)
+
+ if len(blocks) > 0 {
+ if !self.eth.ChainManager().HasBlock(b.PrevHash) && self.pool[string(b.PrevHash)] == nil && !self.fetchingHashes {
+ }
+ }
+ }
+ */
+ }
+ }
+}
+
+func (self *BlockPool) chainThread() {
+ procTimer := time.NewTicker(500 * time.Millisecond)
+out:
+ for {
+ select {
+ case <-self.quit:
+ break out
+ case <-procTimer.C:
+ blocks := self.Blocks()
+ ethchain.BlockBy(ethchain.Number).Sort(blocks)
+
+ // Find common block
+ for i, block := range blocks {
+ if self.eth.ChainManager().HasBlock(block.PrevHash) {
+ blocks = blocks[i:]
+ break
+ }
+ }
+
+ if len(blocks) > 0 {
+ if self.eth.ChainManager().HasBlock(blocks[0].PrevHash) {
+ for i, block := range blocks[1:] {
+ // NOTE: The Ith element in this loop refers to the previous block in
+ // outer "blocks"
+ if bytes.Compare(block.PrevHash, blocks[i].Hash()) != 0 {
+ blocks = blocks[:i]
+
+ break
+ }
+ }
+ } else {
+ blocks = nil
+ }
+ }
+
+ var err error
+ for i, block := range blocks {
+ err = self.eth.StateManager().Process(block, false)
+ if err != nil {
+ poollogger.Infoln(err)
+ poollogger.Debugf("Block #%v failed (%x...)\n", block.Number, block.Hash()[0:4])
+ poollogger.Debugln(block)
+
+ blocks = blocks[i:]
+
+ break
+ }
+
+ self.Remove(block.Hash())
+ }
+
+ if err != nil {
+ self.Reset()
+
+ poollogger.Debugf("Punishing peer for supplying bad chain (%v)\n", self.peer.conn.RemoteAddr())
+ // This peer gave us bad hashes and made us fetch a bad chain, therefor he shall be punished.
+ self.eth.BlacklistPeer(self.peer)
+ self.peer.StopWithReason(DiscBadPeer)
+ self.td = ethutil.Big0
+ self.peer = nil
+ }
+ }
+ }
+}
diff --git a/cmd/LICENSE b/cmd/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..78efdaabe9d71de384bda09447903e48f54f685d
--- /dev/null
+++ b/cmd/LICENSE
@@ -0,0 +1,16 @@
+Copyright (c) 2013-2014, Jeffrey Wilcke. All rights reserved.
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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 General Public License
+along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+MA 02110-1301 USA
diff --git a/ethereum/cmd.go b/cmd/ethereum/cmd.go
similarity index 87%
rename from ethereum/cmd.go
rename to cmd/ethereum/cmd.go
index 5ddc9161901cd684864ecb029d29edf1d75f70af..e99e2931a049dace06bed4e2a5f2e3d52544f1f3 100644
--- a/ethereum/cmd.go
+++ b/cmd/ethereum/cmd.go
@@ -4,8 +4,8 @@ import (
"io/ioutil"
"os"
- "github.com/ethereum/eth-go"
- "github.com/ethereum/go-ethereum/ethereum/repl"
+ "github.com/ethereum/go-ethereum"
+ "github.com/ethereum/go-ethereum/cmd/ethereum/repl"
"github.com/ethereum/go-ethereum/javascript"
"github.com/ethereum/go-ethereum/utils"
)
diff --git a/ethereum/flags.go b/cmd/ethereum/flags.go
similarity index 97%
rename from ethereum/flags.go
rename to cmd/ethereum/flags.go
index af7b3365ac63876ba8c7a38a9dea98e3c1e95de2..92cf97537620fb9f69587bab4ccf758a40635c46 100644
--- a/ethereum/flags.go
+++ b/cmd/ethereum/flags.go
@@ -8,8 +8,8 @@ import (
"os/user"
"path"
- "github.com/ethereum/eth-go/ethlog"
- "github.com/ethereum/eth-go/vm"
+ "github.com/ethereum/go-ethereum/ethlog"
+ "github.com/ethereum/go-ethereum/vm"
)
var (
diff --git a/ethereum/main.go b/cmd/ethereum/main.go
similarity index 94%
rename from ethereum/main.go
rename to cmd/ethereum/main.go
index 21668ad2548845a9630e7d5a5657cc7907eab5ad..f7d7761e8a1b20395f8db827c27d4568cadef11f 100644
--- a/ethereum/main.go
+++ b/cmd/ethereum/main.go
@@ -5,9 +5,9 @@ import (
"os"
"runtime"
- "github.com/ethereum/eth-go/ethchain"
- "github.com/ethereum/eth-go/ethlog"
- "github.com/ethereum/eth-go/ethutil"
+ "github.com/ethereum/go-ethereum/ethchain"
+ "github.com/ethereum/go-ethereum/ethlog"
+ "github.com/ethereum/go-ethereum/ethutil"
"github.com/ethereum/go-ethereum/utils"
)
diff --git a/ethereum/repl/console_colors_windows.go b/cmd/ethereum/repl/console_colors_windows.go
similarity index 100%
rename from ethereum/repl/console_colors_windows.go
rename to cmd/ethereum/repl/console_colors_windows.go
diff --git a/ethereum/repl/repl.go b/cmd/ethereum/repl/repl.go
similarity index 91%
rename from ethereum/repl/repl.go
rename to cmd/ethereum/repl/repl.go
index d08feb7b437cff68f5f6d316b9037d4492c6f5a5..a40a8874ef1fbf923f74ed6c1d08e3a21c42f543 100644
--- a/ethereum/repl/repl.go
+++ b/cmd/ethereum/repl/repl.go
@@ -7,9 +7,9 @@ import (
"os"
"path"
- "github.com/ethereum/eth-go"
- "github.com/ethereum/eth-go/ethlog"
- "github.com/ethereum/eth-go/ethutil"
+ "github.com/ethereum/go-ethereum"
+ "github.com/ethereum/go-ethereum/ethlog"
+ "github.com/ethereum/go-ethereum/ethutil"
"github.com/ethereum/go-ethereum/javascript"
)
diff --git a/ethereum/repl/repl_darwin.go b/cmd/ethereum/repl/repl_darwin.go
similarity index 100%
rename from ethereum/repl/repl_darwin.go
rename to cmd/ethereum/repl/repl_darwin.go
diff --git a/ethereum/repl/repl_linux.go b/cmd/ethereum/repl/repl_linux.go
similarity index 100%
rename from ethereum/repl/repl_linux.go
rename to cmd/ethereum/repl/repl_linux.go
diff --git a/ethereum/repl/repl_windows.go b/cmd/ethereum/repl/repl_windows.go
similarity index 100%
rename from ethereum/repl/repl_windows.go
rename to cmd/ethereum/repl/repl_windows.go
diff --git a/mist/assets/back.png b/cmd/mist/assets/back.png
similarity index 100%
rename from mist/assets/back.png
rename to cmd/mist/assets/back.png
diff --git a/mist/assets/browser.png b/cmd/mist/assets/browser.png
similarity index 100%
rename from mist/assets/browser.png
rename to cmd/mist/assets/browser.png
diff --git a/mist/assets/bug.png b/cmd/mist/assets/bug.png
similarity index 100%
rename from mist/assets/bug.png
rename to cmd/mist/assets/bug.png
diff --git a/mist/assets/close.png b/cmd/mist/assets/close.png
similarity index 100%
rename from mist/assets/close.png
rename to cmd/mist/assets/close.png
diff --git a/mist/assets/debugger/debugger.qml b/cmd/mist/assets/debugger/debugger.qml
similarity index 100%
rename from mist/assets/debugger/debugger.qml
rename to cmd/mist/assets/debugger/debugger.qml
diff --git a/mist/assets/ext/big.js b/cmd/mist/assets/ext/big.js
similarity index 100%
rename from mist/assets/ext/big.js
rename to cmd/mist/assets/ext/big.js
diff --git a/mist/assets/ext/ethereum.js b/cmd/mist/assets/ext/ethereum.js
similarity index 100%
rename from mist/assets/ext/ethereum.js
rename to cmd/mist/assets/ext/ethereum.js
diff --git a/mist/assets/ext/filter.js b/cmd/mist/assets/ext/filter.js
similarity index 100%
rename from mist/assets/ext/filter.js
rename to cmd/mist/assets/ext/filter.js
diff --git a/mist/assets/ext/home.html b/cmd/mist/assets/ext/home.html
similarity index 100%
rename from mist/assets/ext/home.html
rename to cmd/mist/assets/ext/home.html
diff --git a/mist/assets/ext/html_messaging.js b/cmd/mist/assets/ext/html_messaging.js
similarity index 100%
rename from mist/assets/ext/html_messaging.js
rename to cmd/mist/assets/ext/html_messaging.js
diff --git a/mist/assets/ext/http.js b/cmd/mist/assets/ext/http.js
similarity index 100%
rename from mist/assets/ext/http.js
rename to cmd/mist/assets/ext/http.js
diff --git a/mist/assets/ext/q.js b/cmd/mist/assets/ext/q.js
similarity index 100%
rename from mist/assets/ext/q.js
rename to cmd/mist/assets/ext/q.js
diff --git a/mist/assets/ext/qml_messaging.js b/cmd/mist/assets/ext/qml_messaging.js
similarity index 100%
rename from mist/assets/ext/qml_messaging.js
rename to cmd/mist/assets/ext/qml_messaging.js
diff --git a/mist/assets/ext/qt_messaging_adapter.js b/cmd/mist/assets/ext/qt_messaging_adapter.js
similarity index 100%
rename from mist/assets/ext/qt_messaging_adapter.js
rename to cmd/mist/assets/ext/qt_messaging_adapter.js
diff --git a/mist/assets/ext/string.js b/cmd/mist/assets/ext/string.js
similarity index 100%
rename from mist/assets/ext/string.js
rename to cmd/mist/assets/ext/string.js
diff --git a/mist/assets/ext/test.html b/cmd/mist/assets/ext/test.html
similarity index 100%
rename from mist/assets/ext/test.html
rename to cmd/mist/assets/ext/test.html
diff --git a/mist/assets/facet.png b/cmd/mist/assets/facet.png
similarity index 100%
rename from mist/assets/facet.png
rename to cmd/mist/assets/facet.png
diff --git a/mist/assets/heart.png b/cmd/mist/assets/heart.png
similarity index 100%
rename from mist/assets/heart.png
rename to cmd/mist/assets/heart.png
diff --git a/mist/assets/icecream.png b/cmd/mist/assets/icecream.png
similarity index 100%
rename from mist/assets/icecream.png
rename to cmd/mist/assets/icecream.png
diff --git a/mist/assets/muted/codemirror.css b/cmd/mist/assets/muted/codemirror.css
similarity index 100%
rename from mist/assets/muted/codemirror.css
rename to cmd/mist/assets/muted/codemirror.css
diff --git a/mist/assets/muted/debugger.html b/cmd/mist/assets/muted/debugger.html
similarity index 100%
rename from mist/assets/muted/debugger.html
rename to cmd/mist/assets/muted/debugger.html
diff --git a/mist/assets/muted/eclipse.css b/cmd/mist/assets/muted/eclipse.css
similarity index 100%
rename from mist/assets/muted/eclipse.css
rename to cmd/mist/assets/muted/eclipse.css
diff --git a/mist/assets/muted/index.html b/cmd/mist/assets/muted/index.html
similarity index 100%
rename from mist/assets/muted/index.html
rename to cmd/mist/assets/muted/index.html
diff --git a/mist/assets/muted/lib/codemirror.js b/cmd/mist/assets/muted/lib/codemirror.js
similarity index 100%
rename from mist/assets/muted/lib/codemirror.js
rename to cmd/mist/assets/muted/lib/codemirror.js
diff --git a/mist/assets/muted/lib/go.js b/cmd/mist/assets/muted/lib/go.js
similarity index 100%
rename from mist/assets/muted/lib/go.js
rename to cmd/mist/assets/muted/lib/go.js
diff --git a/mist/assets/muted/lib/matchbrackets.js b/cmd/mist/assets/muted/lib/matchbrackets.js
similarity index 100%
rename from mist/assets/muted/lib/matchbrackets.js
rename to cmd/mist/assets/muted/lib/matchbrackets.js
diff --git a/mist/assets/muted/muted.js b/cmd/mist/assets/muted/muted.js
similarity index 100%
rename from mist/assets/muted/muted.js
rename to cmd/mist/assets/muted/muted.js
diff --git a/mist/assets/net.png b/cmd/mist/assets/net.png
similarity index 100%
rename from mist/assets/net.png
rename to cmd/mist/assets/net.png
diff --git a/mist/assets/network.png b/cmd/mist/assets/network.png
similarity index 100%
rename from mist/assets/network.png
rename to cmd/mist/assets/network.png
diff --git a/mist/assets/new.png b/cmd/mist/assets/new.png
similarity index 100%
rename from mist/assets/new.png
rename to cmd/mist/assets/new.png
diff --git a/mist/assets/pick.png b/cmd/mist/assets/pick.png
similarity index 100%
rename from mist/assets/pick.png
rename to cmd/mist/assets/pick.png
diff --git a/mist/assets/qml/QmlApp.qml b/cmd/mist/assets/qml/QmlApp.qml
similarity index 100%
rename from mist/assets/qml/QmlApp.qml
rename to cmd/mist/assets/qml/QmlApp.qml
diff --git a/mist/assets/qml/first_run.qml b/cmd/mist/assets/qml/first_run.qml
similarity index 100%
rename from mist/assets/qml/first_run.qml
rename to cmd/mist/assets/qml/first_run.qml
diff --git a/mist/assets/qml/main.qml b/cmd/mist/assets/qml/main.qml
similarity index 100%
rename from mist/assets/qml/main.qml
rename to cmd/mist/assets/qml/main.qml
diff --git a/mist/assets/qml/muted.qml b/cmd/mist/assets/qml/muted.qml
similarity index 100%
rename from mist/assets/qml/muted.qml
rename to cmd/mist/assets/qml/muted.qml
diff --git a/mist/assets/qml/test_app.qml b/cmd/mist/assets/qml/test_app.qml
similarity index 100%
rename from mist/assets/qml/test_app.qml
rename to cmd/mist/assets/qml/test_app.qml
diff --git a/mist/assets/qml/transactions.qml b/cmd/mist/assets/qml/transactions.qml
similarity index 100%
rename from mist/assets/qml/transactions.qml
rename to cmd/mist/assets/qml/transactions.qml
diff --git a/mist/assets/qml/views/chain.qml b/cmd/mist/assets/qml/views/chain.qml
similarity index 100%
rename from mist/assets/qml/views/chain.qml
rename to cmd/mist/assets/qml/views/chain.qml
diff --git a/mist/assets/qml/views/history.qml b/cmd/mist/assets/qml/views/history.qml
similarity index 100%
rename from mist/assets/qml/views/history.qml
rename to cmd/mist/assets/qml/views/history.qml
diff --git a/mist/assets/qml/views/info.qml b/cmd/mist/assets/qml/views/info.qml
similarity index 100%
rename from mist/assets/qml/views/info.qml
rename to cmd/mist/assets/qml/views/info.qml
diff --git a/mist/assets/qml/views/jeffcoin/jeff.png b/cmd/mist/assets/qml/views/jeffcoin/jeff.png
similarity index 100%
rename from mist/assets/qml/views/jeffcoin/jeff.png
rename to cmd/mist/assets/qml/views/jeffcoin/jeff.png
diff --git a/mist/assets/qml/views/jeffcoin/jeffcoin.qml b/cmd/mist/assets/qml/views/jeffcoin/jeffcoin.qml
similarity index 100%
rename from mist/assets/qml/views/jeffcoin/jeffcoin.qml
rename to cmd/mist/assets/qml/views/jeffcoin/jeffcoin.qml
diff --git a/mist/assets/qml/views/pending_tx.qml b/cmd/mist/assets/qml/views/pending_tx.qml
similarity index 100%
rename from mist/assets/qml/views/pending_tx.qml
rename to cmd/mist/assets/qml/views/pending_tx.qml
diff --git a/mist/assets/qml/views/transaction.qml b/cmd/mist/assets/qml/views/transaction.qml
similarity index 100%
rename from mist/assets/qml/views/transaction.qml
rename to cmd/mist/assets/qml/views/transaction.qml
diff --git a/mist/assets/qml/views/wallet.qml b/cmd/mist/assets/qml/views/wallet.qml
similarity index 100%
rename from mist/assets/qml/views/wallet.qml
rename to cmd/mist/assets/qml/views/wallet.qml
diff --git a/mist/assets/qml/webapp.qml b/cmd/mist/assets/qml/webapp.qml
similarity index 100%
rename from mist/assets/qml/webapp.qml
rename to cmd/mist/assets/qml/webapp.qml
diff --git a/mist/assets/tx.png b/cmd/mist/assets/tx.png
similarity index 100%
rename from mist/assets/tx.png
rename to cmd/mist/assets/tx.png
diff --git a/mist/assets/util/test.html b/cmd/mist/assets/util/test.html
similarity index 100%
rename from mist/assets/util/test.html
rename to cmd/mist/assets/util/test.html
diff --git a/mist/assets/wallet.png b/cmd/mist/assets/wallet.png
similarity index 100%
rename from mist/assets/wallet.png
rename to cmd/mist/assets/wallet.png
diff --git a/mist/bindings.go b/cmd/mist/bindings.go
similarity index 95%
rename from mist/bindings.go
rename to cmd/mist/bindings.go
index 972e4e8ed332f87eb3739593368a41713d80c481..639033a32a7f8644176105078c2bc0482f6c8bab 100644
--- a/mist/bindings.go
+++ b/cmd/mist/bindings.go
@@ -5,10 +5,10 @@ import (
"os"
"strconv"
- "github.com/ethereum/eth-go/ethchain"
- "github.com/ethereum/eth-go/ethlog"
- "github.com/ethereum/eth-go/ethpipe"
- "github.com/ethereum/eth-go/ethutil"
+ "github.com/ethereum/go-ethereum/ethchain"
+ "github.com/ethereum/go-ethereum/ethlog"
+ "github.com/ethereum/go-ethereum/ethpipe"
+ "github.com/ethereum/go-ethereum/ethutil"
"github.com/ethereum/go-ethereum/utils"
)
diff --git a/mist/debugger.go b/cmd/mist/debugger.go
similarity index 97%
rename from mist/debugger.go
rename to cmd/mist/debugger.go
index ebe18c78f6301da43af0b810ee0aa4d82c8bfe9e..a2e60271f37db31769fa5eb0a9a2f8d19146ee4a 100644
--- a/mist/debugger.go
+++ b/cmd/mist/debugger.go
@@ -7,11 +7,11 @@ import (
"strings"
"unicode"
- "github.com/ethereum/eth-go/ethchain"
- "github.com/ethereum/eth-go/ethstate"
- "github.com/ethereum/eth-go/ethutil"
- "github.com/ethereum/eth-go/vm"
+ "github.com/ethereum/go-ethereum/ethchain"
+ "github.com/ethereum/go-ethereum/ethstate"
+ "github.com/ethereum/go-ethereum/ethutil"
"github.com/ethereum/go-ethereum/utils"
+ "github.com/ethereum/go-ethereum/vm"
"gopkg.in/qml.v1"
)
diff --git a/mist/errors.go b/cmd/mist/errors.go
similarity index 100%
rename from mist/errors.go
rename to cmd/mist/errors.go
diff --git a/mist/ext_app.go b/cmd/mist/ext_app.go
similarity index 92%
rename from mist/ext_app.go
rename to cmd/mist/ext_app.go
index c4e6fd39404331ed8f5f3f40911f62c50df12d36..8927a4b256d248d64a3d1a48eb04e58d8fdd0d86 100644
--- a/mist/ext_app.go
+++ b/cmd/mist/ext_app.go
@@ -3,12 +3,12 @@ package main
import (
"encoding/json"
- "github.com/ethereum/eth-go/ethchain"
- "github.com/ethereum/eth-go/ethpipe"
- "github.com/ethereum/eth-go/ethstate"
- "github.com/ethereum/eth-go/event"
- "github.com/ethereum/eth-go/ui/qt"
+ "github.com/ethereum/go-ethereum/ethchain"
+ "github.com/ethereum/go-ethereum/ethpipe"
+ "github.com/ethereum/go-ethereum/ethstate"
+ "github.com/ethereum/go-ethereum/event"
"github.com/ethereum/go-ethereum/javascript"
+ "github.com/ethereum/go-ethereum/ui/qt"
"gopkg.in/qml.v1"
)
diff --git a/mist/flags.go b/cmd/mist/flags.go
similarity index 97%
rename from mist/flags.go
rename to cmd/mist/flags.go
index 68accf1bc225946ac07c23dfb5157ae6f4922a5c..3990f266adb23497a7c326a9c4bfc04776265643 100644
--- a/mist/flags.go
+++ b/cmd/mist/flags.go
@@ -11,8 +11,8 @@ import (
"runtime"
"bitbucket.org/kardianos/osext"
- "github.com/ethereum/eth-go/ethlog"
- "github.com/ethereum/eth-go/vm"
+ "github.com/ethereum/go-ethereum/ethlog"
+ "github.com/ethereum/go-ethereum/vm"
)
var (
diff --git a/mist/gui.go b/cmd/mist/gui.go
similarity index 97%
rename from mist/gui.go
rename to cmd/mist/gui.go
index 2c19680c0e5c1f71d554dbf688aa3b7dc29fc2f7..2a9ab3918cc82914456b2ca8b1cb817e146f4a3f 100644
--- a/mist/gui.go
+++ b/cmd/mist/gui.go
@@ -13,14 +13,14 @@ import (
"strings"
"time"
- "github.com/ethereum/eth-go"
- "github.com/ethereum/eth-go/ethchain"
- "github.com/ethereum/eth-go/ethdb"
- "github.com/ethereum/eth-go/ethlog"
- "github.com/ethereum/eth-go/ethminer"
- "github.com/ethereum/eth-go/ethpipe"
- "github.com/ethereum/eth-go/ethutil"
- "github.com/ethereum/eth-go/ethwire"
+ "github.com/ethereum/go-ethereum"
+ "github.com/ethereum/go-ethereum/ethchain"
+ "github.com/ethereum/go-ethereum/ethdb"
+ "github.com/ethereum/go-ethereum/ethlog"
+ "github.com/ethereum/go-ethereum/ethminer"
+ "github.com/ethereum/go-ethereum/ethpipe"
+ "github.com/ethereum/go-ethereum/ethutil"
+ "github.com/ethereum/go-ethereum/ethwire"
"gopkg.in/qml.v1"
)
diff --git a/mist/html_container.go b/cmd/mist/html_container.go
similarity index 94%
rename from mist/html_container.go
rename to cmd/mist/html_container.go
index 69edea5703bb08106ac969d90907cfc5fc5cf0f7..7dafa025dcecde645bdb1aa7456d4a7e96578d89 100644
--- a/mist/html_container.go
+++ b/cmd/mist/html_container.go
@@ -10,10 +10,10 @@ import (
"path"
"path/filepath"
- "github.com/ethereum/eth-go/ethchain"
- "github.com/ethereum/eth-go/ethpipe"
- "github.com/ethereum/eth-go/ethstate"
- "github.com/ethereum/eth-go/ethutil"
+ "github.com/ethereum/go-ethereum/ethchain"
+ "github.com/ethereum/go-ethereum/ethpipe"
+ "github.com/ethereum/go-ethereum/ethstate"
+ "github.com/ethereum/go-ethereum/ethutil"
"github.com/ethereum/go-ethereum/javascript"
"github.com/howeyc/fsnotify"
"gopkg.in/qml.v1"
diff --git a/mist/main.go b/cmd/mist/main.go
similarity index 96%
rename from mist/main.go
rename to cmd/mist/main.go
index 116bd78fd705d0eecea1d0049277b93fbc27191c..c6cca9de59836426e0cc801a1211ea5848e6e72d 100644
--- a/mist/main.go
+++ b/cmd/mist/main.go
@@ -4,8 +4,8 @@ import (
"os"
"runtime"
- "github.com/ethereum/eth-go"
- "github.com/ethereum/eth-go/ethlog"
+ "github.com/ethereum/go-ethereum"
+ "github.com/ethereum/go-ethereum/ethlog"
"github.com/ethereum/go-ethereum/utils"
"gopkg.in/qml.v1"
)
diff --git a/mist/qml_container.go b/cmd/mist/qml_container.go
similarity index 89%
rename from mist/qml_container.go
rename to cmd/mist/qml_container.go
index 85bd7c69956ed89a94be741d1fb4ee98a7fa2fa5..b0f4f6127d2413711733d5eaf5446ae1ca20126d 100644
--- a/mist/qml_container.go
+++ b/cmd/mist/qml_container.go
@@ -4,10 +4,10 @@ import (
"fmt"
"runtime"
- "github.com/ethereum/eth-go/ethchain"
- "github.com/ethereum/eth-go/ethpipe"
- "github.com/ethereum/eth-go/ethstate"
- "github.com/ethereum/eth-go/ethutil"
+ "github.com/ethereum/go-ethereum/ethchain"
+ "github.com/ethereum/go-ethereum/ethpipe"
+ "github.com/ethereum/go-ethereum/ethstate"
+ "github.com/ethereum/go-ethereum/ethutil"
"gopkg.in/qml.v1"
)
diff --git a/mist/ui_lib.go b/cmd/mist/ui_lib.go
similarity index 95%
rename from mist/ui_lib.go
rename to cmd/mist/ui_lib.go
index 90ba0bbaf1bf572f24c7d29e85cec46cf3c7114c..f44f2f7116be9e9b430dd402b0add918200b6b81 100644
--- a/mist/ui_lib.go
+++ b/cmd/mist/ui_lib.go
@@ -7,14 +7,14 @@ import (
"strconv"
"strings"
- "github.com/ethereum/eth-go"
- "github.com/ethereum/eth-go/ethchain"
- "github.com/ethereum/eth-go/ethcrypto"
- "github.com/ethereum/eth-go/ethpipe"
- "github.com/ethereum/eth-go/ethstate"
- "github.com/ethereum/eth-go/ethutil"
- "github.com/ethereum/eth-go/ui/qt"
+ "github.com/ethereum/go-ethereum"
+ "github.com/ethereum/go-ethereum/ethchain"
+ "github.com/ethereum/go-ethereum/ethcrypto"
+ "github.com/ethereum/go-ethereum/ethpipe"
+ "github.com/ethereum/go-ethereum/ethstate"
+ "github.com/ethereum/go-ethereum/ethutil"
"github.com/ethereum/go-ethereum/javascript"
+ "github.com/ethereum/go-ethereum/ui/qt"
"gopkg.in/qml.v1"
)
diff --git a/ethchain/.gitignore b/ethchain/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..f725d58d14f7d1b6a8c41c45f78b4f38f529ae9e
--- /dev/null
+++ b/ethchain/.gitignore
@@ -0,0 +1,12 @@
+# See http://help.github.com/ignore-files/ for more about ignoring files.
+#
+# If you find yourself ignoring temporary files generated by your text editor
+# or operating system, you probably want to add a global ignore instead:
+# git config --global core.excludesfile ~/.gitignore_global
+
+/tmp
+*/**/*un~
+*un~
+.DS_Store
+*/**/.DS_Store
+
diff --git a/ethchain/asm.go b/ethchain/asm.go
new file mode 100644
index 0000000000000000000000000000000000000000..57bb2fcf9b9ab4b9355a533bd203ee712b4581d9
--- /dev/null
+++ b/ethchain/asm.go
@@ -0,0 +1,45 @@
+package ethchain
+
+import (
+ "fmt"
+ "math/big"
+
+ "github.com/ethereum/go-ethereum/ethutil"
+)
+
+func Disassemble(script []byte) (asm []string) {
+ pc := new(big.Int)
+ for {
+ if pc.Cmp(big.NewInt(int64(len(script)))) >= 0 {
+ return
+ }
+
+ // Get the memory location of pc
+ val := script[pc.Int64()]
+ // Get the opcode (it must be an opcode!)
+ op := OpCode(val)
+
+ asm = append(asm, fmt.Sprintf("%04v: %v", pc, op))
+
+ switch op {
+ 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:
+ pc.Add(pc, ethutil.Big1)
+ a := int64(op) - int64(PUSH1) + 1
+ if int(pc.Int64()+a) > len(script) {
+ return
+ }
+
+ data := script[pc.Int64() : pc.Int64()+a]
+ if len(data) == 0 {
+ data = []byte{0}
+ }
+ asm = append(asm, fmt.Sprintf("%04v: 0x%x", pc, data))
+
+ pc.Add(pc, big.NewInt(a-1))
+ }
+
+ pc.Add(pc, ethutil.Big1)
+ }
+
+ return asm
+}
diff --git a/ethchain/block.go b/ethchain/block.go
new file mode 100644
index 0000000000000000000000000000000000000000..b98d806d8509bb1e6a147ca9109c417220e31c54
--- /dev/null
+++ b/ethchain/block.go
@@ -0,0 +1,439 @@
+package ethchain
+
+import (
+ "bytes"
+ "fmt"
+ "math/big"
+ "sort"
+ _ "strconv"
+ "time"
+
+ "github.com/ethereum/go-ethereum/ethcrypto"
+ "github.com/ethereum/go-ethereum/ethstate"
+ "github.com/ethereum/go-ethereum/ethtrie"
+ "github.com/ethereum/go-ethereum/ethutil"
+)
+
+type BlockInfo struct {
+ Number uint64
+ Hash []byte
+ Parent []byte
+ TD *big.Int
+}
+
+func (bi *BlockInfo) RlpDecode(data []byte) {
+ decoder := ethutil.NewValueFromBytes(data)
+
+ bi.Number = decoder.Get(0).Uint()
+ bi.Hash = decoder.Get(1).Bytes()
+ bi.Parent = decoder.Get(2).Bytes()
+ bi.TD = decoder.Get(3).BigInt()
+}
+
+func (bi *BlockInfo) RlpEncode() []byte {
+ return ethutil.Encode([]interface{}{bi.Number, bi.Hash, bi.Parent, bi.TD})
+}
+
+type Blocks []*Block
+
+func (self Blocks) AsSet() ethutil.UniqueSet {
+ set := make(ethutil.UniqueSet)
+ for _, block := range self {
+ set.Insert(block.Hash())
+ }
+
+ return set
+}
+
+type BlockBy func(b1, b2 *Block) bool
+
+func (self BlockBy) Sort(blocks Blocks) {
+ bs := blockSorter{
+ blocks: blocks,
+ by: self,
+ }
+ sort.Sort(bs)
+}
+
+type blockSorter struct {
+ blocks Blocks
+ by func(b1, b2 *Block) bool
+}
+
+func (self blockSorter) Len() int { return len(self.blocks) }
+func (self blockSorter) Swap(i, j int) {
+ self.blocks[i], self.blocks[j] = self.blocks[j], self.blocks[i]
+}
+func (self blockSorter) Less(i, j int) bool { return self.by(self.blocks[i], self.blocks[j]) }
+
+func Number(b1, b2 *Block) bool { return b1.Number.Cmp(b2.Number) < 0 }
+
+type Block struct {
+ // Hash to the previous block
+ PrevHash ethutil.Bytes
+ // Uncles of this block
+ Uncles Blocks
+ UncleSha []byte
+ // The coin base address
+ Coinbase []byte
+ // Block Trie state
+ //state *ethutil.Trie
+ state *ethstate.State
+ // Difficulty for the current block
+ Difficulty *big.Int
+ // Creation time
+ Time int64
+ // The block number
+ Number *big.Int
+ // Minimum Gas Price
+ MinGasPrice *big.Int
+ // Gas limit
+ GasLimit *big.Int
+ // Gas used
+ GasUsed *big.Int
+ // Extra data
+ Extra string
+ // Block Nonce for verification
+ Nonce ethutil.Bytes
+ // List of transactions and/or contracts
+ transactions []*Transaction
+ receipts []*Receipt
+ TxSha []byte
+}
+
+func NewBlockFromBytes(raw []byte) *Block {
+ block := &Block{}
+ block.RlpDecode(raw)
+
+ return block
+}
+
+// New block takes a raw encoded string
+func NewBlockFromRlpValue(rlpValue *ethutil.Value) *Block {
+ block := &Block{}
+ block.RlpValueDecode(rlpValue)
+
+ return block
+}
+
+func CreateBlock(root interface{},
+ prevHash []byte,
+ base []byte,
+ Difficulty *big.Int,
+ Nonce []byte,
+ extra string) *Block {
+
+ block := &Block{
+ PrevHash: prevHash,
+ Coinbase: base,
+ Difficulty: Difficulty,
+ Nonce: Nonce,
+ Time: time.Now().Unix(),
+ Extra: extra,
+ UncleSha: nil,
+ GasUsed: new(big.Int),
+ MinGasPrice: new(big.Int),
+ GasLimit: new(big.Int),
+ }
+ block.SetUncles([]*Block{})
+
+ block.state = ethstate.New(ethtrie.New(ethutil.Config.Db, root))
+
+ return block
+}
+
+// Returns a hash of the block
+func (block *Block) Hash() ethutil.Bytes {
+ return ethcrypto.Sha3(ethutil.NewValue(block.header()).Encode())
+ //return ethcrypto.Sha3(block.Value().Encode())
+}
+
+func (block *Block) HashNoNonce() []byte {
+ return ethcrypto.Sha3(ethutil.Encode([]interface{}{block.PrevHash,
+ block.UncleSha, block.Coinbase, block.state.Trie.Root,
+ block.TxSha, block.Difficulty, block.Number, block.MinGasPrice,
+ block.GasLimit, block.GasUsed, block.Time, block.Extra}))
+}
+
+func (block *Block) State() *ethstate.State {
+ return block.state
+}
+
+func (block *Block) Transactions() []*Transaction {
+ return block.transactions
+}
+
+func (block *Block) CalcGasLimit(parent *Block) *big.Int {
+ if block.Number.Cmp(big.NewInt(0)) == 0 {
+ return ethutil.BigPow(10, 6)
+ }
+
+ // ((1024-1) * parent.gasLimit + (gasUsed * 6 / 5)) / 1024
+
+ previous := new(big.Int).Mul(big.NewInt(1024-1), parent.GasLimit)
+ current := new(big.Rat).Mul(new(big.Rat).SetInt(parent.GasUsed), big.NewRat(6, 5))
+ curInt := new(big.Int).Div(current.Num(), current.Denom())
+
+ result := new(big.Int).Add(previous, curInt)
+ result.Div(result, big.NewInt(1024))
+
+ min := big.NewInt(125000)
+
+ return ethutil.BigMax(min, result)
+}
+
+func (block *Block) BlockInfo() BlockInfo {
+ bi := BlockInfo{}
+ data, _ := ethutil.Config.Db.Get(append(block.Hash(), []byte("Info")...))
+ bi.RlpDecode(data)
+
+ return bi
+}
+
+func (self *Block) GetTransaction(hash []byte) *Transaction {
+ for _, receipt := range self.receipts {
+ if bytes.Compare(receipt.Tx.Hash(), hash) == 0 {
+ return receipt.Tx
+ }
+ }
+
+ return nil
+}
+
+// Sync the block's state and contract respectively
+func (block *Block) Sync() {
+ block.state.Sync()
+}
+
+func (block *Block) Undo() {
+ // Sync the block state itself
+ block.state.Reset()
+}
+
+/////// Block Encoding
+func (block *Block) rlpReceipts() interface{} {
+ // Marshal the transactions of this block
+ encR := make([]interface{}, len(block.receipts))
+ for i, r := range block.receipts {
+ // Cast it to a string (safe)
+ encR[i] = r.RlpData()
+ }
+
+ return encR
+}
+
+func (block *Block) rlpUncles() interface{} {
+ // Marshal the transactions of this block
+ uncles := make([]interface{}, len(block.Uncles))
+ for i, uncle := range block.Uncles {
+ // Cast it to a string (safe)
+ uncles[i] = uncle.header()
+ }
+
+ return uncles
+}
+
+func (block *Block) SetUncles(uncles []*Block) {
+ block.Uncles = uncles
+
+ // Sha of the concatenated uncles
+ if len(uncles) > 0 {
+ block.UncleSha = ethcrypto.Sha3(ethutil.Encode(block.rlpUncles()))
+ }
+}
+
+func (self *Block) SetReceipts(receipts []*Receipt, txs []*Transaction) {
+ self.receipts = receipts
+ self.setTransactions(txs)
+}
+
+func (block *Block) setTransactions(txs []*Transaction) {
+ block.transactions = txs
+}
+
+func CreateTxSha(receipts Receipts) (sha []byte) {
+ trie := ethtrie.New(ethutil.Config.Db, "")
+ for i, receipt := range receipts {
+ trie.Update(string(ethutil.NewValue(i).Encode()), string(ethutil.NewValue(receipt.RlpData()).Encode()))
+ }
+
+ switch trie.Root.(type) {
+ case string:
+ sha = []byte(trie.Root.(string))
+ case []byte:
+ sha = trie.Root.([]byte)
+ default:
+ panic(fmt.Sprintf("invalid root type %T", trie.Root))
+ }
+
+ return sha
+}
+
+func (self *Block) SetTxHash(receipts Receipts) {
+ self.TxSha = CreateTxSha(receipts)
+}
+
+func (block *Block) Value() *ethutil.Value {
+ return ethutil.NewValue([]interface{}{block.header(), block.rlpReceipts(), block.rlpUncles()})
+}
+
+func (block *Block) RlpEncode() []byte {
+ // Encode a slice interface which contains the header and the list of
+ // transactions.
+ return block.Value().Encode()
+}
+
+func (block *Block) RlpDecode(data []byte) {
+ rlpValue := ethutil.NewValueFromBytes(data)
+ block.RlpValueDecode(rlpValue)
+}
+
+func (block *Block) RlpValueDecode(decoder *ethutil.Value) {
+ header := decoder.Get(0)
+
+ block.PrevHash = header.Get(0).Bytes()
+ block.UncleSha = header.Get(1).Bytes()
+ block.Coinbase = header.Get(2).Bytes()
+ block.state = ethstate.New(ethtrie.New(ethutil.Config.Db, header.Get(3).Val))
+ block.TxSha = header.Get(4).Bytes()
+ block.Difficulty = header.Get(5).BigInt()
+ block.Number = header.Get(6).BigInt()
+ //fmt.Printf("#%v : %x\n", block.Number, block.Coinbase)
+ block.MinGasPrice = header.Get(7).BigInt()
+ block.GasLimit = header.Get(8).BigInt()
+ block.GasUsed = header.Get(9).BigInt()
+ block.Time = int64(header.Get(10).BigInt().Uint64())
+ block.Extra = header.Get(11).Str()
+ block.Nonce = header.Get(12).Bytes()
+
+ // Tx list might be empty if this is an uncle. Uncles only have their
+ // header set.
+ if decoder.Get(1).IsNil() == false { // Yes explicitness
+ receipts := decoder.Get(1)
+ block.transactions = make([]*Transaction, receipts.Len())
+ block.receipts = make([]*Receipt, receipts.Len())
+ for i := 0; i < receipts.Len(); i++ {
+ receipt := NewRecieptFromValue(receipts.Get(i))
+ block.transactions[i] = receipt.Tx
+ block.receipts[i] = receipt
+ }
+
+ }
+
+ if decoder.Get(2).IsNil() == false { // Yes explicitness
+ uncles := decoder.Get(2)
+ block.Uncles = make([]*Block, uncles.Len())
+ for i := 0; i < uncles.Len(); i++ {
+ block.Uncles[i] = NewUncleBlockFromValue(uncles.Get(i))
+ }
+ }
+
+}
+
+func NewUncleBlockFromValue(header *ethutil.Value) *Block {
+ block := &Block{}
+
+ block.PrevHash = header.Get(0).Bytes()
+ block.UncleSha = header.Get(1).Bytes()
+ block.Coinbase = header.Get(2).Bytes()
+ block.state = ethstate.New(ethtrie.New(ethutil.Config.Db, header.Get(3).Val))
+ block.TxSha = header.Get(4).Bytes()
+ block.Difficulty = header.Get(5).BigInt()
+ block.Number = header.Get(6).BigInt()
+ block.MinGasPrice = header.Get(7).BigInt()
+ block.GasLimit = header.Get(8).BigInt()
+ block.GasUsed = header.Get(9).BigInt()
+ block.Time = int64(header.Get(10).BigInt().Uint64())
+ block.Extra = header.Get(11).Str()
+ block.Nonce = header.Get(12).Bytes()
+
+ return block
+}
+
+func (block *Block) Trie() *ethtrie.Trie {
+ return block.state.Trie
+}
+
+func (block *Block) GetRoot() interface{} {
+ return block.state.Trie.Root
+}
+
+func (block *Block) Diff() *big.Int {
+ return block.Difficulty
+}
+
+func (self *Block) Receipts() []*Receipt {
+ return self.receipts
+}
+
+func (block *Block) header() []interface{} {
+ return []interface{}{
+ // Sha of the previous block
+ block.PrevHash,
+ // Sha of uncles
+ block.UncleSha,
+ // Coinbase address
+ block.Coinbase,
+ // root state
+ block.state.Trie.Root,
+ // Sha of tx
+ block.TxSha,
+ // Current block Difficulty
+ block.Difficulty,
+ // The block number
+ block.Number,
+ // Block minimum gas price
+ block.MinGasPrice,
+ // Block upper gas bound
+ block.GasLimit,
+ // Block gas used
+ block.GasUsed,
+ // Time the block was found?
+ block.Time,
+ // Extra data
+ block.Extra,
+ // Block's Nonce for validation
+ block.Nonce,
+ }
+}
+
+func (block *Block) String() string {
+ return fmt.Sprintf(`
+ BLOCK(%x): Size: %v
+ PrevHash: %x
+ UncleSha: %x
+ Coinbase: %x
+ Root: %x
+ TxSha: %x
+ Difficulty: %v
+ Number: %v
+ MinGas: %v
+ MaxLimit: %v
+ GasUsed: %v
+ Time: %v
+ Extra: %v
+ Nonce: %x
+ NumTx: %v
+`,
+ block.Hash(),
+ block.Size(),
+ block.PrevHash,
+ block.UncleSha,
+ block.Coinbase,
+ block.state.Trie.Root,
+ block.TxSha,
+ block.Difficulty,
+ block.Number,
+ block.MinGasPrice,
+ block.GasLimit,
+ block.GasUsed,
+ block.Time,
+ block.Extra,
+ block.Nonce,
+ len(block.transactions),
+ )
+}
+
+func (self *Block) Size() ethutil.StorageSize {
+ return ethutil.StorageSize(len(self.RlpEncode()))
+}
diff --git a/ethchain/bloom.go b/ethchain/bloom.go
new file mode 100644
index 0000000000000000000000000000000000000000..5317ca0b1c94a178dfdb6d591c2fa518511c28fc
--- /dev/null
+++ b/ethchain/bloom.go
@@ -0,0 +1,47 @@
+package ethchain
+
+type BloomFilter struct {
+ bin []byte
+}
+
+func NewBloomFilter(bin []byte) *BloomFilter {
+ if bin == nil {
+ bin = make([]byte, 256)
+ }
+
+ return &BloomFilter{
+ bin: bin,
+ }
+}
+
+func (self *BloomFilter) Set(addr []byte) {
+ if len(addr) < 8 {
+ chainlogger.Warnf("err: bloom set to small: %x\n", addr)
+
+ return
+ }
+
+ for _, i := range addr[len(addr)-8:] {
+ self.bin[i] = 1
+ }
+}
+
+func (self *BloomFilter) Search(addr []byte) bool {
+ if len(addr) < 8 {
+ chainlogger.Warnf("err: bloom search to small: %x\n", addr)
+
+ return false
+ }
+
+ for _, i := range addr[len(addr)-8:] {
+ if self.bin[i] == 0 {
+ return false
+ }
+ }
+
+ return true
+}
+
+func (self *BloomFilter) Bin() []byte {
+ return self.bin
+}
diff --git a/ethchain/bloom_test.go b/ethchain/bloom_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..ea53d539c4bca4f1ac7b02c941fd1639610c17e5
--- /dev/null
+++ b/ethchain/bloom_test.go
@@ -0,0 +1,20 @@
+package ethchain
+
+import "testing"
+
+func TestBloomFilter(t *testing.T) {
+ bf := NewBloomFilter(nil)
+
+ a := []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}
+ bf.Set(a)
+
+ b := []byte{10, 11, 12, 13, 14, 15, 16, 17, 18, 19}
+
+ if bf.Search(a) == false {
+ t.Error("Expected 'a' to yield true using a bloom filter")
+ }
+
+ if bf.Search(b) {
+ t.Error("Expected 'b' not to field trie using a bloom filter")
+ }
+}
diff --git a/ethchain/chain_manager.go b/ethchain/chain_manager.go
new file mode 100644
index 0000000000000000000000000000000000000000..d949f0ce742c0e96dea15ab62d7183291d596873
--- /dev/null
+++ b/ethchain/chain_manager.go
@@ -0,0 +1,291 @@
+package ethchain
+
+import (
+ "bytes"
+ "fmt"
+ "math/big"
+
+ "github.com/ethereum/go-ethereum/ethlog"
+ "github.com/ethereum/go-ethereum/ethutil"
+)
+
+var chainlogger = ethlog.NewLogger("CHAIN")
+
+type ChainManager struct {
+ Ethereum EthManager
+ // The famous, the fabulous Mister GENESIIIIIIS (block)
+ genesisBlock *Block
+ // Last known total difficulty
+ TD *big.Int
+
+ LastBlockNumber uint64
+
+ CurrentBlock *Block
+ LastBlockHash []byte
+}
+
+func NewChainManager(ethereum EthManager) *ChainManager {
+ bc := &ChainManager{}
+ bc.genesisBlock = NewBlockFromBytes(ethutil.Encode(Genesis))
+ bc.Ethereum = ethereum
+
+ bc.setLastBlock()
+
+ return bc
+}
+
+func (bc *ChainManager) Genesis() *Block {
+ return bc.genesisBlock
+}
+
+func (bc *ChainManager) NewBlock(coinbase []byte) *Block {
+ var root interface{}
+ hash := ZeroHash256
+
+ if bc.CurrentBlock != nil {
+ root = bc.CurrentBlock.state.Trie.Root
+ hash = bc.LastBlockHash
+ }
+
+ block := CreateBlock(
+ root,
+ hash,
+ coinbase,
+ ethutil.BigPow(2, 32),
+ nil,
+ "")
+
+ block.MinGasPrice = big.NewInt(10000000000000)
+
+ parent := bc.CurrentBlock
+ if parent != nil {
+ block.Difficulty = CalcDifficulty(block, parent)
+ block.Number = new(big.Int).Add(bc.CurrentBlock.Number, ethutil.Big1)
+ block.GasLimit = block.CalcGasLimit(bc.CurrentBlock)
+
+ }
+
+ return block
+}
+
+func CalcDifficulty(block, parent *Block) *big.Int {
+ diff := new(big.Int)
+
+ adjust := new(big.Int).Rsh(parent.Difficulty, 10)
+ if block.Time >= parent.Time+5 {
+ diff.Sub(parent.Difficulty, adjust)
+ } else {
+ diff.Add(parent.Difficulty, adjust)
+ }
+
+ return diff
+}
+
+func (bc *ChainManager) Reset() {
+ AddTestNetFunds(bc.genesisBlock)
+
+ bc.genesisBlock.state.Trie.Sync()
+ // Prepare the genesis block
+ bc.Add(bc.genesisBlock)
+ fk := append([]byte("bloom"), bc.genesisBlock.Hash()...)
+ bc.Ethereum.Db().Put(fk, make([]byte, 255))
+ bc.CurrentBlock = bc.genesisBlock
+
+ bc.SetTotalDifficulty(ethutil.Big("0"))
+
+ // Set the last know difficulty (might be 0x0 as initial value, Genesis)
+ bc.TD = ethutil.BigD(ethutil.Config.Db.LastKnownTD())
+}
+
+func (bc *ChainManager) HasBlock(hash []byte) bool {
+ data, _ := ethutil.Config.Db.Get(hash)
+ return len(data) != 0
+}
+
+// TODO: At one point we might want to save a block by prevHash in the db to optimise this...
+func (bc *ChainManager) HasBlockWithPrevHash(hash []byte) bool {
+ block := bc.CurrentBlock
+
+ for ; block != nil; block = bc.GetBlock(block.PrevHash) {
+ if bytes.Compare(hash, block.PrevHash) == 0 {
+ return true
+ }
+ }
+ return false
+}
+
+func (bc *ChainManager) CalculateBlockTD(block *Block) *big.Int {
+ blockDiff := new(big.Int)
+
+ for _, uncle := range block.Uncles {
+ blockDiff = blockDiff.Add(blockDiff, uncle.Difficulty)
+ }
+ blockDiff = blockDiff.Add(blockDiff, block.Difficulty)
+
+ return blockDiff
+}
+
+func (bc *ChainManager) GenesisBlock() *Block {
+ return bc.genesisBlock
+}
+
+func (self *ChainManager) GetChainHashesFromHash(hash []byte, max uint64) (chain [][]byte) {
+ block := self.GetBlock(hash)
+ if block == nil {
+ return
+ }
+
+ // XXX Could be optimised by using a different database which only holds hashes (i.e., linked list)
+ for i := uint64(0); i < max; i++ {
+ chain = append(chain, block.Hash())
+
+ if block.Number.Cmp(ethutil.Big0) <= 0 {
+ break
+ }
+
+ block = self.GetBlock(block.PrevHash)
+ }
+
+ return
+}
+
+func AddTestNetFunds(block *Block) {
+ for _, addr := range []string{
+ "51ba59315b3a95761d0863b05ccc7a7f54703d99",
+ "e4157b34ea9615cfbde6b4fda419828124b70c78",
+ "b9c015918bdaba24b4ff057a92a3873d6eb201be",
+ "6c386a4b26f73c802f34673f7248bb118f97424a",
+ "cd2a3d9f938e13cd947ec05abc7fe734df8dd826",
+ "2ef47100e0787b915105fd5e3f4ff6752079d5cb",
+ "e6716f9544a56c530d868e4bfbacb172315bdead",
+ "1a26338f0d905e295fccb71fa9ea849ffa12aaf4",
+ } {
+ codedAddr := ethutil.Hex2Bytes(addr)
+ account := block.state.GetAccount(codedAddr)
+ account.SetBalance(ethutil.Big("1606938044258990275541962092341162602522202993782792835301376")) //ethutil.BigPow(2, 200)
+ block.state.UpdateStateObject(account)
+ }
+}
+
+func (bc *ChainManager) setLastBlock() {
+ data, _ := ethutil.Config.Db.Get([]byte("LastBlock"))
+ if len(data) != 0 {
+ // Prep genesis
+ AddTestNetFunds(bc.genesisBlock)
+
+ block := NewBlockFromBytes(data)
+ bc.CurrentBlock = block
+ bc.LastBlockHash = block.Hash()
+ bc.LastBlockNumber = block.Number.Uint64()
+
+ // Set the last know difficulty (might be 0x0 as initial value, Genesis)
+ bc.TD = ethutil.BigD(ethutil.Config.Db.LastKnownTD())
+ } else {
+ bc.Reset()
+ }
+
+ chainlogger.Infof("Last block (#%d) %x\n", bc.LastBlockNumber, bc.CurrentBlock.Hash())
+}
+
+func (bc *ChainManager) SetTotalDifficulty(td *big.Int) {
+ ethutil.Config.Db.Put([]byte("LTD"), td.Bytes())
+ bc.TD = td
+}
+
+// Add a block to the chain and record addition information
+func (bc *ChainManager) Add(block *Block) {
+ bc.writeBlockInfo(block)
+ // Prepare the genesis block
+
+ bc.CurrentBlock = block
+ bc.LastBlockHash = block.Hash()
+
+ encodedBlock := block.RlpEncode()
+ ethutil.Config.Db.Put(block.Hash(), encodedBlock)
+ ethutil.Config.Db.Put([]byte("LastBlock"), encodedBlock)
+}
+
+func (self *ChainManager) CalcTotalDiff(block *Block) (*big.Int, error) {
+ parent := self.GetBlock(block.PrevHash)
+ if parent == nil {
+ return nil, fmt.Errorf("Unable to calculate total diff without known parent %x", block.PrevHash)
+ }
+
+ parentTd := parent.BlockInfo().TD
+
+ uncleDiff := new(big.Int)
+ for _, uncle := range block.Uncles {
+ uncleDiff = uncleDiff.Add(uncleDiff, uncle.Difficulty)
+ }
+
+ td := new(big.Int)
+ td = td.Add(parentTd, uncleDiff)
+ td = td.Add(td, block.Difficulty)
+
+ return td, nil
+}
+
+func (bc *ChainManager) GetBlock(hash []byte) *Block {
+ data, _ := ethutil.Config.Db.Get(hash)
+ if len(data) == 0 {
+ return nil
+ }
+
+ return NewBlockFromBytes(data)
+}
+
+func (self *ChainManager) GetBlockByNumber(num uint64) *Block {
+ block := self.CurrentBlock
+ for ; block != nil; block = self.GetBlock(block.PrevHash) {
+ if block.Number.Uint64() == num {
+ break
+ }
+ }
+
+ if block != nil && block.Number.Uint64() == 0 && num != 0 {
+ return nil
+ }
+
+ return block
+}
+
+func (self *ChainManager) GetBlockBack(num uint64) *Block {
+ block := self.CurrentBlock
+
+ for ; num != 0 && block != nil; num-- {
+ block = self.GetBlock(block.PrevHash)
+ }
+
+ return block
+}
+
+func (bc *ChainManager) BlockInfoByHash(hash []byte) BlockInfo {
+ bi := BlockInfo{}
+ data, _ := ethutil.Config.Db.Get(append(hash, []byte("Info")...))
+ bi.RlpDecode(data)
+
+ return bi
+}
+
+func (bc *ChainManager) BlockInfo(block *Block) BlockInfo {
+ bi := BlockInfo{}
+ data, _ := ethutil.Config.Db.Get(append(block.Hash(), []byte("Info")...))
+ bi.RlpDecode(data)
+
+ return bi
+}
+
+// Unexported method for writing extra non-essential block info to the db
+func (bc *ChainManager) writeBlockInfo(block *Block) {
+ bc.LastBlockNumber++
+ bi := BlockInfo{Number: bc.LastBlockNumber, Hash: block.Hash(), Parent: block.PrevHash, TD: bc.TD}
+
+ // For now we use the block hash with the words "info" appended as key
+ ethutil.Config.Db.Put(append(block.Hash(), []byte("Info")...), bi.RlpEncode())
+}
+
+func (bc *ChainManager) Stop() {
+ if bc.CurrentBlock != nil {
+ chainlogger.Infoln("Stopped")
+ }
+}
diff --git a/ethchain/chain_manager_test.go b/ethchain/chain_manager_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..3603fd8a783708c6afc59213793338cb7f4fcc02
--- /dev/null
+++ b/ethchain/chain_manager_test.go
@@ -0,0 +1 @@
+package ethchain
diff --git a/ethchain/dagger.go b/ethchain/dagger.go
new file mode 100644
index 0000000000000000000000000000000000000000..7efcf469debd18b508cf6c76296ee595340db281
--- /dev/null
+++ b/ethchain/dagger.go
@@ -0,0 +1,239 @@
+package ethchain
+
+import (
+ "hash"
+ "math/big"
+ "math/rand"
+ "time"
+
+ "github.com/ethereum/go-ethereum/ethcrypto"
+ "github.com/ethereum/go-ethereum/ethlog"
+ "github.com/ethereum/go-ethereum/ethutil"
+ "github.com/obscuren/sha3"
+)
+
+var powlogger = ethlog.NewLogger("POW")
+
+type PoW interface {
+ Search(block *Block, stop <-chan struct{}) []byte
+ Verify(hash []byte, diff *big.Int, nonce []byte) bool
+ GetHashrate() int64
+ Turbo(bool)
+}
+
+type EasyPow struct {
+ hash *big.Int
+ HashRate int64
+ turbo bool
+}
+
+func (pow *EasyPow) GetHashrate() int64 {
+ return pow.HashRate
+}
+
+func (pow *EasyPow) Turbo(on bool) {
+ pow.turbo = on
+}
+
+func (pow *EasyPow) Search(block *Block, stop <-chan struct{}) []byte {
+ r := rand.New(rand.NewSource(time.Now().UnixNano()))
+ hash := block.HashNoNonce()
+ diff := block.Difficulty
+ i := int64(0)
+ start := time.Now().UnixNano()
+ t := time.Now()
+
+ for {
+ select {
+ case <-stop:
+ powlogger.Infoln("Breaking from mining")
+ return nil
+ default:
+ i++
+
+ if time.Since(t) > (1 * time.Second) {
+ elapsed := time.Now().UnixNano() - start
+ hashes := ((float64(1e9) / float64(elapsed)) * float64(i)) / 1000
+ pow.HashRate = int64(hashes)
+ powlogger.Infoln("Hashing @", int64(pow.HashRate), "khash")
+
+ t = time.Now()
+ }
+
+ sha := ethcrypto.Sha3(big.NewInt(r.Int63()).Bytes())
+ if pow.Verify(hash, diff, sha) {
+ return sha
+ }
+ }
+
+ if !pow.turbo {
+ time.Sleep(20 * time.Microsecond)
+ }
+ }
+
+ return nil
+}
+
+func (pow *EasyPow) Verify(hash []byte, diff *big.Int, nonce []byte) bool {
+ sha := sha3.NewKeccak256()
+
+ d := append(hash, nonce...)
+ sha.Write(d)
+
+ v := ethutil.BigPow(2, 256)
+ ret := new(big.Int).Div(v, diff)
+
+ res := new(big.Int)
+ res.SetBytes(sha.Sum(nil))
+
+ return res.Cmp(ret) == -1
+}
+
+func (pow *EasyPow) SetHash(hash *big.Int) {
+}
+
+type Dagger struct {
+ hash *big.Int
+ xn *big.Int
+}
+
+var Found bool
+
+func (dag *Dagger) Find(obj *big.Int, resChan chan int64) {
+ r := rand.New(rand.NewSource(time.Now().UnixNano()))
+
+ for i := 0; i < 1000; i++ {
+ rnd := r.Int63()
+
+ res := dag.Eval(big.NewInt(rnd))
+ powlogger.Infof("rnd %v\nres %v\nobj %v\n", rnd, res, obj)
+ if res.Cmp(obj) < 0 {
+ // Post back result on the channel
+ resChan <- rnd
+ // Notify other threads we've found a valid nonce
+ Found = true
+ }
+
+ // Break out if found
+ if Found {
+ break
+ }
+ }
+
+ resChan <- 0
+}
+
+func (dag *Dagger) Search(hash, diff *big.Int) *big.Int {
+ // TODO fix multi threading. Somehow it results in the wrong nonce
+ amountOfRoutines := 1
+
+ dag.hash = hash
+
+ obj := ethutil.BigPow(2, 256)
+ obj = obj.Div(obj, diff)
+
+ Found = false
+ resChan := make(chan int64, 3)
+ var res int64
+
+ for k := 0; k < amountOfRoutines; k++ {
+ go dag.Find(obj, resChan)
+
+ // Wait for each go routine to finish
+ }
+ for k := 0; k < amountOfRoutines; k++ {
+ // Get the result from the channel. 0 = quit
+ if r := <-resChan; r != 0 {
+ res = r
+ }
+ }
+
+ return big.NewInt(res)
+}
+
+func (dag *Dagger) Verify(hash, diff, nonce *big.Int) bool {
+ dag.hash = hash
+
+ obj := ethutil.BigPow(2, 256)
+ obj = obj.Div(obj, diff)
+
+ return dag.Eval(nonce).Cmp(obj) < 0
+}
+
+func DaggerVerify(hash, diff, nonce *big.Int) bool {
+ dagger := &Dagger{}
+ dagger.hash = hash
+
+ obj := ethutil.BigPow(2, 256)
+ obj = obj.Div(obj, diff)
+
+ return dagger.Eval(nonce).Cmp(obj) < 0
+}
+
+func (dag *Dagger) Node(L uint64, i uint64) *big.Int {
+ if L == i {
+ return dag.hash
+ }
+
+ var m *big.Int
+ if L == 9 {
+ m = big.NewInt(16)
+ } else {
+ m = big.NewInt(3)
+ }
+
+ sha := sha3.NewKeccak256()
+ sha.Reset()
+ d := sha3.NewKeccak256()
+ b := new(big.Int)
+ ret := new(big.Int)
+
+ for k := 0; k < int(m.Uint64()); k++ {
+ d.Reset()
+ d.Write(dag.hash.Bytes())
+ d.Write(dag.xn.Bytes())
+ d.Write(big.NewInt(int64(L)).Bytes())
+ d.Write(big.NewInt(int64(i)).Bytes())
+ d.Write(big.NewInt(int64(k)).Bytes())
+
+ b.SetBytes(Sum(d))
+ pk := b.Uint64() & ((1 << ((L - 1) * 3)) - 1)
+ sha.Write(dag.Node(L-1, pk).Bytes())
+ }
+
+ ret.SetBytes(Sum(sha))
+
+ return ret
+}
+
+func Sum(sha hash.Hash) []byte {
+ //in := make([]byte, 32)
+ return sha.Sum(nil)
+}
+
+func (dag *Dagger) Eval(N *big.Int) *big.Int {
+ pow := ethutil.BigPow(2, 26)
+ dag.xn = pow.Div(N, pow)
+
+ sha := sha3.NewKeccak256()
+ sha.Reset()
+ ret := new(big.Int)
+
+ for k := 0; k < 4; k++ {
+ d := sha3.NewKeccak256()
+ b := new(big.Int)
+
+ d.Reset()
+ d.Write(dag.hash.Bytes())
+ d.Write(dag.xn.Bytes())
+ d.Write(N.Bytes())
+ d.Write(big.NewInt(int64(k)).Bytes())
+
+ b.SetBytes(Sum(d))
+ pk := (b.Uint64() & 0x1ffffff)
+
+ sha.Write(dag.Node(9, pk).Bytes())
+ }
+
+ return ret.SetBytes(Sum(sha))
+}
diff --git a/ethchain/dagger_test.go b/ethchain/dagger_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..2ffba0485dab55879d0b37d13c81c27f46c5a534
--- /dev/null
+++ b/ethchain/dagger_test.go
@@ -0,0 +1,19 @@
+package ethchain
+
+import (
+ "math/big"
+ "testing"
+
+ "github.com/ethereum/go-ethereum/ethutil"
+)
+
+func BenchmarkDaggerSearch(b *testing.B) {
+ hash := big.NewInt(0)
+ diff := ethutil.BigPow(2, 36)
+ o := big.NewInt(0) // nonce doesn't matter. We're only testing against speed, not validity
+
+ // Reset timer so the big generation isn't included in the benchmark
+ b.ResetTimer()
+ // Validate
+ DaggerVerify(hash, diff, o)
+}
diff --git a/ethchain/error.go b/ethchain/error.go
new file mode 100644
index 0000000000000000000000000000000000000000..82949141ab3fb274c4553b73e3cf9c3f48b9191e
--- /dev/null
+++ b/ethchain/error.go
@@ -0,0 +1,116 @@
+package ethchain
+
+import (
+ "fmt"
+ "math/big"
+)
+
+// Parent error. In case a parent is unknown this error will be thrown
+// by the block manager
+type ParentErr struct {
+ Message string
+}
+
+func (err *ParentErr) Error() string {
+ return err.Message
+}
+
+func ParentError(hash []byte) error {
+ return &ParentErr{Message: fmt.Sprintf("Block's parent unkown %x", hash)}
+}
+
+func IsParentErr(err error) bool {
+ _, ok := err.(*ParentErr)
+
+ return ok
+}
+
+type UncleErr struct {
+ Message string
+}
+
+func (err *UncleErr) Error() string {
+ return err.Message
+}
+
+func UncleError(str string) error {
+ return &UncleErr{Message: str}
+}
+
+func IsUncleErr(err error) bool {
+ _, ok := err.(*UncleErr)
+
+ return ok
+}
+
+// Block validation error. If any validation fails, this error will be thrown
+type ValidationErr struct {
+ Message string
+}
+
+func (err *ValidationErr) Error() string {
+ return err.Message
+}
+
+func ValidationError(format string, v ...interface{}) *ValidationErr {
+ return &ValidationErr{Message: fmt.Sprintf(format, v...)}
+}
+
+func IsValidationErr(err error) bool {
+ _, ok := err.(*ValidationErr)
+
+ return ok
+}
+
+type GasLimitErr struct {
+ Message string
+ Is, Max *big.Int
+}
+
+func IsGasLimitErr(err error) bool {
+ _, ok := err.(*GasLimitErr)
+
+ return ok
+}
+func (err *GasLimitErr) Error() string {
+ return err.Message
+}
+func GasLimitError(is, max *big.Int) *GasLimitErr {
+ return &GasLimitErr{Message: fmt.Sprintf("GasLimit error. Max %s, transaction would take it to %s", max, is), Is: is, Max: max}
+}
+
+type NonceErr struct {
+ Message string
+ Is, Exp uint64
+}
+
+func (err *NonceErr) Error() string {
+ return err.Message
+}
+
+func NonceError(is, exp uint64) *NonceErr {
+ return &NonceErr{Message: fmt.Sprintf("Nonce err. Is %d, expected %d", is, exp), Is: is, Exp: exp}
+}
+
+func IsNonceErr(err error) bool {
+ _, ok := err.(*NonceErr)
+
+ return ok
+}
+
+type OutOfGasErr struct {
+ Message string
+}
+
+func OutOfGasError() *OutOfGasErr {
+ return &OutOfGasErr{Message: "Out of gas"}
+}
+func (self *OutOfGasErr) Error() string {
+ return self.Message
+}
+
+func IsOutOfGasErr(err error) bool {
+ _, ok := err.(*OutOfGasErr)
+
+ return ok
+}
diff --git a/ethchain/events.go b/ethchain/events.go
new file mode 100644
index 0000000000000000000000000000000000000000..05c21edfe40fbb90731d00dc4ca63574a59b8d2f
--- /dev/null
+++ b/ethchain/events.go
@@ -0,0 +1,10 @@
+package ethchain
+
+type TxEvent struct {
+ Type int // TxPre || TxPost
+ Tx *Transaction
+}
+
+type NewBlockEvent struct {
+ Block *Block
+}
diff --git a/ethchain/fees.go b/ethchain/fees.go
new file mode 100644
index 0000000000000000000000000000000000000000..901357439be2571f1edbb149c635d900dc4ac32c
--- /dev/null
+++ b/ethchain/fees.go
@@ -0,0 +1,7 @@
+package ethchain
+
+import (
+ "math/big"
+)
+
+var BlockReward *big.Int = big.NewInt(1.5e+18)
diff --git a/ethchain/filter.go b/ethchain/filter.go
new file mode 100644
index 0000000000000000000000000000000000000000..4e7fe68a89af29305fae4e12cf8a890b2ec09dce
--- /dev/null
+++ b/ethchain/filter.go
@@ -0,0 +1,206 @@
+package ethchain
+
+import (
+ "bytes"
+ "fmt"
+ "math"
+
+ "github.com/ethereum/go-ethereum/ethstate"
+)
+
+type AccountChange struct {
+ Address, StateAddress []byte
+}
+
+// Filtering interface
+type Filter struct {
+ eth EthManager
+ earliest int64
+ latest int64
+ skip int
+ from, to [][]byte
+ max int
+
+ Altered []AccountChange
+
+ BlockCallback func(*Block)
+ MessageCallback func(ethstate.Messages)
+}
+
+// Create a new filter which uses a bloom filter on blocks to figure out whether a particular block
+// is interesting or not.
+func NewFilter(eth EthManager) *Filter {
+ return &Filter{eth: eth}
+}
+
+func (self *Filter) AddAltered(address, stateAddress []byte) {
+ self.Altered = append(self.Altered, AccountChange{address, stateAddress})
+}
+
+// Set the earliest and latest block for filtering.
+// -1 = latest block (i.e., the current block)
+// hash = particular hash from-to
+func (self *Filter) SetEarliestBlock(earliest int64) {
+ self.earliest = earliest
+}
+
+func (self *Filter) SetLatestBlock(latest int64) {
+ self.latest = latest
+}
+
+func (self *Filter) SetFrom(addr [][]byte) {
+ self.from = addr
+}
+
+func (self *Filter) AddFrom(addr []byte) {
+ self.from = append(self.from, addr)
+}
+
+func (self *Filter) SetTo(addr [][]byte) {
+ self.to = addr
+}
+
+func (self *Filter) AddTo(addr []byte) {
+ self.to = append(self.to, addr)
+}
+
+func (self *Filter) SetMax(max int) {
+ self.max = max
+}
+
+func (self *Filter) SetSkip(skip int) {
+ self.skip = skip
+}
+
+// Run filters messages with the current parameters set
+func (self *Filter) Find() []*ethstate.Message {
+ var earliestBlockNo uint64 = uint64(self.earliest)
+ if self.earliest == -1 {
+ earliestBlockNo = self.eth.ChainManager().CurrentBlock.Number.Uint64()
+ }
+ var latestBlockNo uint64 = uint64(self.latest)
+ if self.latest == -1 {
+ latestBlockNo = self.eth.ChainManager().CurrentBlock.Number.Uint64()
+ }
+
+ var (
+ messages []*ethstate.Message
+ block = self.eth.ChainManager().GetBlockByNumber(latestBlockNo)
+ quit bool
+ )
+ for i := 0; !quit && block != nil; i++ {
+ // Quit on latest
+ switch {
+ case block.Number.Uint64() == earliestBlockNo:
+ quit = true
+ case self.max <= len(messages):
+ break
+ }
+
+ // Use bloom filtering to see if this block is interesting given the
+ // current parameters
+ if self.bloomFilter(block) {
+ // Get the messages of the block
+ msgs, err := self.eth.StateManager().GetMessages(block)
+ if err != nil {
+ chainlogger.Warnln("err: filter get messages ", err)
+
+ break
+ }
+
+ messages = append(messages, self.FilterMessages(msgs)...)
+ }
+
+ block = self.eth.ChainManager().GetBlock(block.PrevHash)
+ }
+
+ skip := int(math.Min(float64(len(messages)), float64(self.skip)))
+
+ return messages[skip:]
+}
+
+func includes(addresses [][]byte, a []byte) (found bool) {
+ for _, addr := range addresses {
+ if bytes.Compare(addr, a) == 0 {
+ return true
+ }
+ }
+
+ return
+}
+
+func (self *Filter) FilterMessages(msgs []*ethstate.Message) []*ethstate.Message {
+ var messages []*ethstate.Message
+
+ // Filter the messages for interesting stuff
+ for _, message := range msgs {
+ if len(self.to) > 0 && !includes(self.to, message.To) {
+ continue
+ }
+
+ if len(self.from) > 0 && !includes(self.from, message.From) {
+ continue
+ }
+
+ var match bool
+ if len(self.Altered) == 0 {
+ match = true
+ }
+
+ for _, accountChange := range self.Altered {
+ if len(accountChange.Address) > 0 && bytes.Compare(message.To, accountChange.Address) != 0 {
+ continue
+ }
+
+ if len(accountChange.StateAddress) > 0 && !includes(message.ChangedAddresses, accountChange.StateAddress) {
+ continue
+ }
+
+ match = true
+ break
+ }
+
+ if !match {
+ continue
+ }
+
+ messages = append(messages, message)
+ }
+
+ return messages
+}
+
+func (self *Filter) bloomFilter(block *Block) bool {
+ fk := append([]byte("bloom"), block.Hash()...)
+ bin, err := self.eth.Db().Get(fk)
+ if err != nil {
+ fmt.Println(err)
+ }
+
+ bloom := NewBloomFilter(bin)
+
+ var fromIncluded, toIncluded bool
+ if len(self.from) > 0 {
+ for _, from := range self.from {
+ if bloom.Search(from) {
+ fromIncluded = true
+ break
+ }
+ }
+ } else {
+ fromIncluded = true
+ }
+
+ if len(self.to) > 0 {
+ for _, to := range self.to {
+ if bloom.Search(to) {
+ toIncluded = true
+ break
+ }
+ }
+ } else {
+ toIncluded = true
+ }
+
+ return fromIncluded && toIncluded
+}
diff --git a/ethchain/filter_test.go b/ethchain/filter_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..e569b3774890bd00a9d10fe88cdc17c9c267a89f
--- /dev/null
+++ b/ethchain/filter_test.go
@@ -0,0 +1,7 @@
+package ethchain
+
+import "testing"
+
+func TestFilter(t *testing.T) {
+ NewFilter(NewTestManager())
+}
diff --git a/ethchain/genesis.go b/ethchain/genesis.go
new file mode 100644
index 0000000000000000000000000000000000000000..232986d53a1b9c682354795310e8cb917631899c
--- /dev/null
+++ b/ethchain/genesis.go
@@ -0,0 +1,48 @@
+package ethchain
+
+import (
+ "math/big"
+
+ "github.com/ethereum/go-ethereum/ethcrypto"
+ "github.com/ethereum/go-ethereum/ethutil"
+)
+
+/*
+ * This is the special genesis block.
+ */
+
+var ZeroHash256 = make([]byte, 32)
+var ZeroHash160 = make([]byte, 20)
+var EmptyShaList = ethcrypto.Sha3(ethutil.Encode([]interface{}{}))
+
+var GenesisHeader = []interface{}{
+ // Previous hash (none)
+ ZeroHash256,
+ // Empty uncles
+ "",
+ // Coinbase
+ ZeroHash160,
+ // Root state
+ "",
+ // tx sha
+ "",
+ // Difficulty
+ //ethutil.BigPow(2, 22),
+ big.NewInt(131072),
+ // Number
+ ethutil.Big0,
+ // Block minimum gas price
+ ethutil.Big0,
+ // Block upper gas bound
+ big.NewInt(1000000),
+ // Block gas used
+ ethutil.Big0,
+ // Time
+ ethutil.Big0,
+ // Extra
+ nil,
+ // Nonce
+ ethcrypto.Sha3(big.NewInt(42).Bytes()),
+}
+
+var Genesis = []interface{}{GenesisHeader, []interface{}{}, []interface{}{}}
diff --git a/ethchain/helper_test.go b/ethchain/helper_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..e4aef67d03c82a7689860d7455acce9744f918e0
--- /dev/null
+++ b/ethchain/helper_test.go
@@ -0,0 +1,92 @@
+package ethchain
+
+import (
+ "container/list"
+ "fmt"
+
+ "github.com/ethereum/go-ethereum/ethcrypto"
+ "github.com/ethereum/go-ethereum/ethdb"
+ "github.com/ethereum/go-ethereum/ethutil"
+ "github.com/ethereum/go-ethereum/ethwire"
+ "github.com/ethereum/go-ethereum/event"
+)
+
+// Implement our EthTest Manager
+type TestManager struct {
+ stateManager *StateManager
+ eventMux *event.TypeMux
+
+ db ethutil.Database
+ txPool *TxPool
+ blockChain *BlockChain
+ Blocks []*Block
+}
+
+func (s *TestManager) IsListening() bool {
+ return false
+}
+
+func (s *TestManager) IsMining() bool {
+ return false
+}
+
+func (s *TestManager) PeerCount() int {
+ return 0
+}
+
+func (s *TestManager) Peers() *list.List {
+ return list.New()
+}
+
+func (s *TestManager) BlockChain() *BlockChain {
+ return s.blockChain
+}
+
+func (tm *TestManager) TxPool() *TxPool {
+ return tm.txPool
+}
+
+func (tm *TestManager) StateManager() *StateManager {
+ return tm.stateManager
+}
+
+func (tm *TestManager) EventMux() *event.TypeMux {
+ return tm.eventMux
+}
+func (tm *TestManager) Broadcast(msgType ethwire.MsgType, data []interface{}) {
+ fmt.Println("Broadcast not implemented")
+}
+
+func (tm *TestManager) ClientIdentity() ethwire.ClientIdentity {
+ return nil
+}
+func (tm *TestManager) KeyManager() *ethcrypto.KeyManager {
+ return nil
+}
+
+func (tm *TestManager) Db() ethutil.Database {
+ return tm.db
+}
+
+func NewTestManager() *TestManager {
+ ethutil.ReadConfig(".ethtest", "/tmp/ethtest", "ETH")
+
+ db, err := ethdb.NewMemDatabase()
+ if err != nil {
+ fmt.Println("Could not create mem-db, failing")
+ return nil
+ }
+ ethutil.Config.Db = db
+
+ testManager := &TestManager{}
+ testManager.eventMux = new(event.TypeMux)
+ testManager.db = db
+ testManager.txPool = NewTxPool(testManager)
+ testManager.blockChain = NewBlockChain(testManager)
+ testManager.stateManager = NewStateManager(testManager)
+
+ // Start the tx pool
+ testManager.txPool.Start()
+
+ return testManager
+}
diff --git a/ethchain/state_manager.go b/ethchain/state_manager.go
new file mode 100644
index 0000000000000000000000000000000000000000..1de46b3713447a0b9a16bb02caaead014ae185d7
--- /dev/null
+++ b/ethchain/state_manager.go
@@ -0,0 +1,446 @@
+package ethchain
+
+import (
+ "bytes"
+ "container/list"
+ "fmt"
+ "math/big"
+ "os"
+ "sync"
+ "time"
+
+ "github.com/ethereum/go-ethereum/ethcrypto"
+ "github.com/ethereum/go-ethereum/ethlog"
+ "github.com/ethereum/go-ethereum/ethstate"
+ "github.com/ethereum/go-ethereum/ethutil"
+ "github.com/ethereum/go-ethereum/ethwire"
+ "github.com/ethereum/go-ethereum/event"
+)
+
+var statelogger = ethlog.NewLogger("STATE")
+
+type Peer interface {
+ Inbound() bool
+ LastSend() time.Time
+ LastPong() int64
+ Host() []byte
+ Port() uint16
+ Version() string
+ PingTime() string
+ Connected() *int32
+ Caps() *ethutil.Value
+}
+
+type EthManager interface {
+ StateManager() *StateManager
+ ChainManager() *ChainManager
+ TxPool() *TxPool
+ Broadcast(msgType ethwire.MsgType, data []interface{})
+ PeerCount() int
+ IsMining() bool
+ IsListening() bool
+ Peers() *list.List
+ KeyManager() *ethcrypto.KeyManager
+ ClientIdentity() ethwire.ClientIdentity
+ Db() ethutil.Database
+ EventMux() *event.TypeMux
+}
+
+type StateManager struct {
+ // Mutex for locking the block processor. Blocks can only be handled one at a time
+ mutex sync.Mutex
+ // Canonical block chain
+ bc *ChainManager
+ // non-persistent key/value memory storage
+ mem map[string]*big.Int
+ // Proof of work used for validating
+ Pow PoW
+ // The ethereum manager interface
+ eth EthManager
+ // The managed states
+ // Transiently state. The trans state isn't ever saved, validated and
+ // it could be used for setting account nonces without effecting
+ // the main states.
+ transState *ethstate.State
+ // Mining state. The mining state is used purely and solely by the mining
+ // operation.
+ miningState *ethstate.State
+
+ // The last attempted block is mainly used for debugging purposes
+ // This does not have to be a valid block and will be set during
+ // 'Process' & canonical validation.
+ lastAttemptedBlock *Block
+
+ events event.Subscription
+}
+
+func NewStateManager(ethereum EthManager) *StateManager {
+ sm := &StateManager{
+ mem: make(map[string]*big.Int),
+ Pow: &EasyPow{},
+ eth: ethereum,
+ bc: ethereum.ChainManager(),
+ }
+ sm.transState = ethereum.ChainManager().CurrentBlock.State().Copy()
+ sm.miningState = ethereum.ChainManager().CurrentBlock.State().Copy()
+
+ return sm
+}
+
+func (self *StateManager) Start() {
+ statelogger.Debugln("Starting state manager")
+ self.events = self.eth.EventMux().Subscribe(Blocks(nil))
+ go self.updateThread()
+}
+
+func (self *StateManager) Stop() {
+ statelogger.Debugln("Stopping state manager")
+ self.events.Unsubscribe()
+}
+
+func (self *StateManager) updateThread() {
+ for ev := range self.events.Chan() {
+ for _, block := range ev.(Blocks) {
+ err := self.Process(block, false)
+ if err != nil {
+ statelogger.Infoln(err)
+ statelogger.Debugf("Block #%v failed (%x...)\n", block.Number, block.Hash()[0:4])
+ statelogger.Debugln(block)
+ break
+ }
+ }
+ }
+}
+
+func (sm *StateManager) CurrentState() *ethstate.State {
+ return sm.eth.ChainManager().CurrentBlock.State()
+}
+
+func (sm *StateManager) TransState() *ethstate.State {
+ return sm.transState
+}
+
+func (sm *StateManager) MiningState() *ethstate.State {
+ return sm.miningState
+}
+
+func (sm *StateManager) NewMiningState() *ethstate.State {
+ sm.miningState = sm.eth.ChainManager().CurrentBlock.State().Copy()
+
+ return sm.miningState
+}
+
+func (sm *StateManager) ChainManager() *ChainManager {
+ return sm.bc
+}
+
+func (self *StateManager) ProcessTransactions(coinbase *ethstate.StateObject, state *ethstate.State, block, parent *Block, txs Transactions) (Receipts, Transactions, Transactions, error) {
+ var (
+ receipts Receipts
+ handled, unhandled Transactions
+ totalUsedGas = big.NewInt(0)
+ err error
+ )
+
+done:
+ for i, tx := range txs {
+ txGas := new(big.Int).Set(tx.Gas)
+
+ cb := state.GetStateObject(coinbase.Address())
+ st := NewStateTransition(cb, tx, state, block)
+ err = st.TransitionState()
+ if err != nil {
+ statelogger.Infoln(err)
+ switch {
+ case IsNonceErr(err):
+ err = nil // ignore error
+ continue
+ case IsGasLimitErr(err):
+ unhandled = txs[i:]
+
+ break done
+ default:
+ statelogger.Infoln(err)
+ err = nil
+ //return nil, nil, nil, err
+ }
+ }
+
+ // Update the state with pending changes
+ state.Update()
+
+ txGas.Sub(txGas, st.gas)
+ accumelative := new(big.Int).Set(totalUsedGas.Add(totalUsedGas, txGas))
+ receipt := &Receipt{tx, ethutil.CopyBytes(state.Root().([]byte)), accumelative}
+
+ if i < len(block.Receipts()) {
+ original := block.Receipts()[i]
+ if !original.Cmp(receipt) {
+ if ethutil.Config.Diff {
+ os.Exit(1)
+ }
+
+ err := fmt.Errorf("#%d receipt failed (r) %v ~ %x <=> (c) %v ~ %x (%x...)", i+1, original.CumulativeGasUsed, original.PostState[0:4], receipt.CumulativeGasUsed, receipt.PostState[0:4], receipt.Tx.Hash()[0:4])
+
+ return nil, nil, nil, err
+ }
+ }
+
+ // Notify all subscribers
+ self.eth.EventMux().Post(TxEvent{TxPost, tx})
+
+ receipts = append(receipts, receipt)
+ handled = append(handled, tx)
+
+ if ethutil.Config.Diff && ethutil.Config.DiffType == "all" {
+ state.CreateOutputForDiff()
+ }
+ }
+
+ parent.GasUsed = totalUsedGas
+
+ return receipts, handled, unhandled, err
+}
+
+func (sm *StateManager) Process(block *Block, dontReact bool) (err error) {
+ // Processing a blocks may never happen simultaneously
+ sm.mutex.Lock()
+ defer sm.mutex.Unlock()
+
+ if sm.bc.HasBlock(block.Hash()) {
+ return nil
+ }
+
+ if !sm.bc.HasBlock(block.PrevHash) {
+ return ParentError(block.PrevHash)
+ }
+
+ sm.lastAttemptedBlock = block
+
+ var (
+ parent = sm.bc.GetBlock(block.PrevHash)
+ state = parent.State()
+ )
+
+ // Defer the Undo on the Trie. If the block processing happened
+ // we don't want to undo but since undo only happens on dirty
+ // nodes this won't happen because Commit would have been called
+ // before that.
+ defer state.Reset()
+
+ if ethutil.Config.Diff && ethutil.Config.DiffType == "all" {
+ fmt.Printf("## %x %x ##\n", block.Hash(), block.Number)
+ }
+
+ receipts, err := sm.ApplyDiff(state, parent, block)
+ if err != nil {
+ return err
+ }
+
+ txSha := CreateTxSha(receipts)
+ if bytes.Compare(txSha, block.TxSha) != 0 {
+ return fmt.Errorf("Error validating tx sha. Received %x, got %x", block.TxSha, txSha)
+ }
+
+ // Block validation
+ if err = sm.ValidateBlock(block); err != nil {
+ statelogger.Errorln("Error validating block:", err)
+ return err
+ }
+
+ if err = sm.AccumelateRewards(state, block, parent); err != nil {
+ statelogger.Errorln("Error accumulating reward", err)
+ return err
+ }
+
+ state.Update()
+
+ if !block.State().Cmp(state) {
+ err = fmt.Errorf("Invalid merkle root.\nrec: %x\nis: %x", block.State().Trie.Root, state.Trie.Root)
+ return
+ }
+
+ // Calculate the new total difficulty and sync back to the db
+ if sm.CalculateTD(block) {
+ // Sync the current block's state to the database and cancelling out the deferred Undo
+ state.Sync()
+
+ // Add the block to the chain
+ sm.bc.Add(block)
+
+ sm.transState = state.Copy()
+
+ // Create a bloom bin for this block
+ filter := sm.createBloomFilter(state)
+ // Persist the data
+ fk := append([]byte("bloom"), block.Hash()...)
+ sm.eth.Db().Put(fk, filter.Bin())
+
+ statelogger.Infof("Imported block #%d (%x...)\n", block.Number, block.Hash()[0:4])
+ if dontReact == false {
+ sm.eth.EventMux().Post(NewBlockEvent{block})
+
+ state.Manifest().Reset()
+ }
+
+ sm.eth.TxPool().RemoveInvalid(state)
+ } else {
+ statelogger.Errorln("total diff failed")
+ }
+
+ return nil
+}
+
+func (sm *StateManager) ApplyDiff(state *ethstate.State, parent, block *Block) (receipts Receipts, err error) {
+ coinbase := state.GetOrNewStateObject(block.Coinbase)
+ coinbase.SetGasPool(block.CalcGasLimit(parent))
+
+ // Process the transactions on to current block
+ receipts, _, _, err = sm.ProcessTransactions(coinbase, state, block, parent, block.Transactions())
+ if err != nil {
+ return nil, err
+ }
+
+ return receipts, nil
+}
+
+func (sm *StateManager) CalculateTD(block *Block) bool {
+ uncleDiff := new(big.Int)
+ for _, uncle := range block.Uncles {
+ uncleDiff = uncleDiff.Add(uncleDiff, uncle.Difficulty)
+ }
+
+ // TD(genesis_block) = 0 and TD(B) = TD(B.parent) + sum(u.difficulty for u in B.uncles) + B.difficulty
+ td := new(big.Int)
+ td = td.Add(sm.bc.TD, uncleDiff)
+ td = td.Add(td, block.Difficulty)
+
+ // The new TD will only be accepted if the new difficulty is
+ // is greater than the previous.
+ if td.Cmp(sm.bc.TD) > 0 {
+ // Set the new total difficulty back to the block chain
+ sm.bc.SetTotalDifficulty(td)
+
+ return true
+ }
+
+ return false
+}
+
+// Validates the current block. Returns an error if the block was invalid,
+// an uncle or anything that isn't on the current block chain.
+// Validation validates easy over difficult (dagger takes longer time = difficult)
+func (sm *StateManager) ValidateBlock(block *Block) error {
+ // Check each uncle's previous hash. In order for it to be valid
+ // is if it has the same block hash as the current
+ parent := sm.bc.GetBlock(block.PrevHash)
+ /*
+ for _, uncle := range block.Uncles {
+ if bytes.Compare(uncle.PrevHash,parent.PrevHash) != 0 {
+ return ValidationError("Mismatch uncle's previous hash. Expected %x, got %x",parent.PrevHash, uncle.PrevHash)
+ }
+ }
+ */
+
+ expd := CalcDifficulty(block, parent)
+ if expd.Cmp(block.Difficulty) < 0 {
+ return fmt.Errorf("Difficulty check failed for block %v, %v", block.Difficulty, expd)
+ }
+
+ diff := block.Time - parent.Time
+ if diff < 0 {
+ return ValidationError("Block timestamp less then prev block %v (%v - %v)", diff, block.Time, sm.bc.CurrentBlock.Time)
+ }
+
+ /* XXX
+ // New blocks must be within the 15 minute range of the last block.
+ if diff > int64(15*time.Minute) {
+ return ValidationError("Block is too far in the future of last block (> 15 minutes)")
+ }
+ */
+
+ // Verify the nonce of the block. Return an error if it's not valid
+ if !sm.Pow.Verify(block.HashNoNonce(), block.Difficulty, block.Nonce) {
+ return ValidationError("Block's nonce is invalid (= %v)", ethutil.Bytes2Hex(block.Nonce))
+ }
+
+ return nil
+}
+
+func (sm *StateManager) AccumelateRewards(state *ethstate.State, block, parent *Block) error {
+ reward := new(big.Int).Set(BlockReward)
+
+ knownUncles := ethutil.Set(parent.Uncles)
+ nonces := ethutil.NewSet(block.Nonce)
+ for _, uncle := range block.Uncles {
+ if nonces.Include(uncle.Nonce) {
+ // Error not unique
+ return UncleError("Uncle not unique")
+ }
+
+ uncleParent := sm.bc.GetBlock(uncle.PrevHash)
+ if uncleParent == nil {
+ return UncleError("Uncle's parent unknown")
+ }
+
+ if uncleParent.Number.Cmp(new(big.Int).Sub(parent.Number, big.NewInt(6))) < 0 {
+ return UncleError("Uncle too old")
+ }
+
+ if knownUncles.Include(uncle.Hash()) {
+ return UncleError("Uncle in chain")
+ }
+
+ nonces.Insert(uncle.Nonce)
+
+ r := new(big.Int)
+ r.Mul(BlockReward, big.NewInt(15)).Div(r, big.NewInt(16))
+
+ uncleAccount := state.GetAccount(uncle.Coinbase)
+ uncleAccount.AddAmount(r)
+
+ reward.Add(reward, new(big.Int).Div(BlockReward, big.NewInt(32)))
+ }
+
+ // Get the account associated with the coinbase
+ account := state.GetAccount(block.Coinbase)
+ // Reward amount of ether to the coinbase address
+ account.AddAmount(reward)
+
+ return nil
+}
+
+// Manifest will handle both creating notifications and generating bloom bin data
+func (sm *StateManager) createBloomFilter(state *ethstate.State) *BloomFilter {
+ bloomf := NewBloomFilter(nil)
+
+ for _, msg := range state.Manifest().Messages {
+ bloomf.Set(msg.To)
+ bloomf.Set(msg.From)
+ }
+
+ sm.eth.EventMux().Post(state.Manifest().Messages)
+
+ return bloomf
+}
+
+func (sm *StateManager) GetMessages(block *Block) (messages []*ethstate.Message, err error) {
+ if !sm.bc.HasBlock(block.PrevHash) {
+ return nil, ParentError(block.PrevHash)
+ }
+
+ sm.lastAttemptedBlock = block
+
+ var (
+ parent = sm.bc.GetBlock(block.PrevHash)
+ state = parent.State().Copy()
+ )
+
+ defer state.Reset()
+
+ sm.ApplyDiff(state, parent, block)
+
+ sm.AccumelateRewards(state, block, parent)
+
+ return state.Manifest().Messages, nil
+}
diff --git a/ethchain/state_transition.go b/ethchain/state_transition.go
new file mode 100644
index 0000000000000000000000000000000000000000..1274915d54f44c409caf376657e980610e0b6a5d
--- /dev/null
+++ b/ethchain/state_transition.go
@@ -0,0 +1,276 @@
+package ethchain
+
+import (
+ "fmt"
+ "math/big"
+
+ "github.com/ethereum/go-ethereum/ethstate"
+ "github.com/ethereum/go-ethereum/ethtrie"
+ "github.com/ethereum/go-ethereum/ethutil"
+ "github.com/ethereum/go-ethereum/vm"
+)
+
+/*
+ * The State transitioning model
+ *
+ * A state transition is a change made when a transaction is applied to the current world state
+ * The state transitioning model does all all the necessary work to work out a valid new state root.
+ * 1) Nonce handling
+ * 2) Pre pay / buy gas of the coinbase (miner)
+ * 3) Create a new state object if the recipient is \0*32
+ * 4) Value transfer
+ * == If contract creation ==
+ * 4a) Attempt to run transaction data
+ * 4b) If valid, use result as code for the new state object
+ * == end ==
+ * 5) Run Script section
+ * 6) Derive new state root
+ */
+type StateTransition struct {
+ coinbase, receiver []byte
+ tx *Transaction
+ gas, gasPrice *big.Int
+ value *big.Int
+ data []byte
+ state *ethstate.State
+ block *Block
+
+ cb, rec, sen *ethstate.StateObject
+}
+
+func NewStateTransition(coinbase *ethstate.StateObject, tx *Transaction, state *ethstate.State, block *Block) *StateTransition {
+ return &StateTransition{coinbase.Address(), tx.Recipient, tx, new(big.Int), new(big.Int).Set(tx.GasPrice), tx.Value, tx.Data, state, block, coinbase, nil, nil}
+}
+
+func (self *StateTransition) Coinbase() *ethstate.StateObject {
+ if self.cb != nil {
+ return self.cb
+ }
+
+ self.cb = self.state.GetOrNewStateObject(self.coinbase)
+ return self.cb
+}
+func (self *StateTransition) Sender() *ethstate.StateObject {
+ if self.sen != nil {
+ return self.sen
+ }
+
+ self.sen = self.state.GetOrNewStateObject(self.tx.Sender())
+
+ return self.sen
+}
+func (self *StateTransition) Receiver() *ethstate.StateObject {
+ if self.tx != nil && self.tx.CreatesContract() {
+ return nil
+ }
+
+ if self.rec != nil {
+ return self.rec
+ }
+
+ self.rec = self.state.GetOrNewStateObject(self.tx.Recipient)
+ return self.rec
+}
+
+func (self *StateTransition) UseGas(amount *big.Int) error {
+ if self.gas.Cmp(amount) < 0 {
+ return OutOfGasError()
+ }
+ self.gas.Sub(self.gas, amount)
+
+ return nil
+}
+
+func (self *StateTransition) AddGas(amount *big.Int) {
+ self.gas.Add(self.gas, amount)
+}
+
+func (self *StateTransition) BuyGas() error {
+ var err error
+
+ sender := self.Sender()
+ if sender.Balance().Cmp(self.tx.GasValue()) < 0 {
+ return fmt.Errorf("Insufficient funds to pre-pay gas. Req %v, has %v", self.tx.GasValue(), sender.Balance())
+ }
+
+ coinbase := self.Coinbase()
+ err = coinbase.BuyGas(self.tx.Gas, self.tx.GasPrice)
+ if err != nil {
+ return err
+ }
+
+ self.AddGas(self.tx.Gas)
+ sender.SubAmount(self.tx.GasValue())
+
+ return nil
+}
+
+func (self *StateTransition) RefundGas() {
+ coinbase, sender := self.Coinbase(), self.Sender()
+ coinbase.RefundGas(self.gas, self.tx.GasPrice)
+
+ // Return remaining gas
+ remaining := new(big.Int).Mul(self.gas, self.tx.GasPrice)
+ sender.AddAmount(remaining)
+}
+
+func (self *StateTransition) preCheck() (err error) {
+ var (
+ tx = self.tx
+ sender = self.Sender()
+ )
+
+ // Make sure this transaction's nonce is correct
+ if sender.Nonce != tx.Nonce {
+ return NonceError(tx.Nonce, sender.Nonce)
+ }
+
+ // Pre-pay gas / Buy gas of the coinbase account
+ if err = self.BuyGas(); err != nil {
+ return err
+ }
+
+ return nil
+}
+
+func (self *StateTransition) TransitionState() (err error) {
+ statelogger.Debugf("(~) %x\n", self.tx.Hash())
+
+ defer func() {
+ if r := recover(); r != nil {
+ statelogger.Infoln(r)
+ err = fmt.Errorf("state transition err %v", r)
+ }
+ }()
+
+ // XXX Transactions after this point are considered valid.
+ if err = self.preCheck(); err != nil {
+ return
+ }
+
+ var (
+ tx = self.tx
+ sender = self.Sender()
+ receiver *ethstate.StateObject
+ )
+
+ defer self.RefundGas()
+
+ // Increment the nonce for the next transaction
+ sender.Nonce += 1
+
+ // Transaction gas
+ if err = self.UseGas(vm.GasTx); err != nil {
+ return
+ }
+
+ // Pay data gas
+ dataPrice := big.NewInt(int64(len(self.data)))
+ dataPrice.Mul(dataPrice, vm.GasData)
+ if err = self.UseGas(dataPrice); err != nil {
+ return
+ }
+
+ if sender.Balance().Cmp(self.value) < 0 {
+ return fmt.Errorf("Insufficient funds to transfer value. Req %v, has %v", self.value, sender.Balance)
+ }
+
+ var snapshot *ethstate.State
+ // If the receiver is nil it's a contract (\0*32).
+ if tx.CreatesContract() {
+ // Subtract the (irreversible) amount from the senders account
+ sender.SubAmount(self.value)
+
+ snapshot = self.state.Copy()
+
+ // Create a new state object for the contract
+ receiver := MakeContract(tx, self.state)
+ self.rec = receiver
+ if receiver == nil {
+ return fmt.Errorf("Unable to create contract")
+ }
+
+ // Add the amount to receivers account which should conclude this transaction
+ receiver.AddAmount(self.value)
+ } else {
+ receiver = self.Receiver()
+
+ // Subtract the amount from the senders account
+ sender.SubAmount(self.value)
+ // Add the amount to receivers account which should conclude this transaction
+ receiver.AddAmount(self.value)
+
+ snapshot = self.state.Copy()
+ }
+
+ msg := self.state.Manifest().AddMessage(ðstate.Message{
+ To: receiver.Address(), From: sender.Address(),
+ Input: self.tx.Data,
+ Origin: sender.Address(),
+ Block: self.block.Hash(), Timestamp: self.block.Time, Coinbase: self.block.Coinbase, Number: self.block.Number,
+ Value: self.value,
+ })
+
+ // Process the init code and create 'valid' contract
+ if IsContractAddr(self.receiver) {
+ // Evaluate the initialization script
+ // and use the return value as the
+ // script section for the state object.
+ self.data = nil
+
+ code, err := self.Eval(msg, receiver.Init(), receiver)
+ if err != nil {
+ self.state.Set(snapshot)
+
+ return fmt.Errorf("Error during init execution %v", err)
+ }
+
+ receiver.Code = code
+ msg.Output = code
+ } else {
+ if len(receiver.Code) > 0 {
+ ret, err := self.Eval(msg, receiver.Code, receiver)
+ if err != nil {
+ self.state.Set(snapshot)
+
+ return fmt.Errorf("Error during code execution %v", err)
+ }
+
+ msg.Output = ret
+ }
+ }
+
+ return
+}
+
+func (self *StateTransition) Eval(msg *ethstate.Message, script []byte, context *ethstate.StateObject) (ret []byte, err error) {
+ var (
+ transactor = self.Sender()
+ state = self.state
+ env = NewEnv(state, self.tx, self.block)
+ callerClosure = vm.NewClosure(msg, transactor, context, script, self.gas, self.gasPrice)
+ )
+
+ //vm := vm.New(env, vm.Type(ethutil.Config.VmType))
+ evm := vm.New(env, vm.DebugVmTy)
+
+ ret, _, err = callerClosure.Call(evm, self.tx.Data)
+
+ return
+}
+
+// Converts an transaction in to a state object
+func MakeContract(tx *Transaction, state *ethstate.State) *ethstate.StateObject {
+ // Create contract if there's no recipient
+ if tx.IsContract() {
+ addr := tx.CreationAddress(state)
+
+ contract := state.GetOrNewStateObject(addr)
+ contract.InitCode = tx.Data
+ contract.State = ethstate.New(ethtrie.New(ethutil.Config.Db, ""))
+
+ return contract
+ }
+
+ return nil
+}
diff --git a/ethchain/transaction.go b/ethchain/transaction.go
new file mode 100644
index 0000000000000000000000000000000000000000..c78c27ed6f3095fa6831dc62a62f972dd84df599
--- /dev/null
+++ b/ethchain/transaction.go
@@ -0,0 +1,257 @@
+package ethchain
+
+import (
+ "bytes"
+ "fmt"
+ "math/big"
+
+ "github.com/ethereum/go-ethereum/ethcrypto"
+ "github.com/ethereum/go-ethereum/ethstate"
+ "github.com/ethereum/go-ethereum/ethutil"
+ "github.com/obscuren/secp256k1-go"
+)
+
+var ContractAddr = []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
+
+func IsContractAddr(addr []byte) bool {
+ return len(addr) == 0
+ //return bytes.Compare(addr, ContractAddr) == 0
+}
+
+type Transaction struct {
+ Nonce uint64
+ Recipient []byte
+ Value *big.Int
+ Gas *big.Int
+ GasPrice *big.Int
+ Data []byte
+ v byte
+ r, s []byte
+
+ // Indicates whether this tx is a contract creation transaction
+ contractCreation bool
+}
+
+func NewContractCreationTx(value, gas, gasPrice *big.Int, script []byte) *Transaction {
+ return &Transaction{Recipient: nil, Value: value, Gas: gas, GasPrice: gasPrice, Data: script, contractCreation: true}
+}
+
+func NewTransactionMessage(to []byte, value, gas, gasPrice *big.Int, data []byte) *Transaction {
+ return &Transaction{Recipient: to, Value: value, GasPrice: gasPrice, Gas: gas, Data: data}
+}
+
+func NewTransactionFromBytes(data []byte) *Transaction {
+ tx := &Transaction{}
+ tx.RlpDecode(data)
+
+ return tx
+}
+
+func NewTransactionFromValue(val *ethutil.Value) *Transaction {
+ tx := &Transaction{}
+ tx.RlpValueDecode(val)
+
+ return tx
+}
+
+func (self *Transaction) GasValue() *big.Int {
+ return new(big.Int).Mul(self.Gas, self.GasPrice)
+}
+
+func (self *Transaction) TotalValue() *big.Int {
+ v := self.GasValue()
+ return v.Add(v, self.Value)
+}
+
+func (tx *Transaction) Hash() []byte {
+ data := []interface{}{tx.Nonce, tx.GasPrice, tx.Gas, tx.Recipient, tx.Value, tx.Data}
+
+ return ethcrypto.Sha3(ethutil.NewValue(data).Encode())
+}
+
+func (tx *Transaction) CreatesContract() bool {
+ return tx.contractCreation
+}
+
+/* Deprecated */
+func (tx *Transaction) IsContract() bool {
+ return tx.CreatesContract()
+}
+
+func (tx *Transaction) CreationAddress(state *ethstate.State) []byte {
+ // Generate a new address
+ addr := ethcrypto.Sha3(ethutil.NewValue([]interface{}{tx.Sender(), tx.Nonce}).Encode())[12:]
+ //for i := uint64(0); state.GetStateObject(addr) != nil; i++ {
+ // addr = ethcrypto.Sha3(ethutil.NewValue([]interface{}{tx.Sender(), tx.Nonce + i}).Encode())[12:]
+ //}
+
+ return addr
+}
+
+func (tx *Transaction) Signature(key []byte) []byte {
+ hash := tx.Hash()
+
+ sig, _ := secp256k1.Sign(hash, key)
+
+ return sig
+}
+
+func (tx *Transaction) PublicKey() []byte {
+ hash := tx.Hash()
+
+ // TODO
+ r := ethutil.LeftPadBytes(tx.r, 32)
+ s := ethutil.LeftPadBytes(tx.s, 32)
+
+ sig := append(r, s...)
+ sig = append(sig, tx.v-27)
+
+ pubkey, _ := secp256k1.RecoverPubkey(hash, sig)
+
+ return pubkey
+}
+
+func (tx *Transaction) Sender() []byte {
+ pubkey := tx.PublicKey()
+
+ // Validate the returned key.
+ // Return nil if public key isn't in full format
+ if pubkey[0] != 4 {
+ return nil
+ }
+
+ return ethcrypto.Sha3(pubkey[1:])[12:]
+}
+
+func (tx *Transaction) Sign(privk []byte) error {
+
+ sig := tx.Signature(privk)
+
+ tx.r = sig[:32]
+ tx.s = sig[32:64]
+ tx.v = sig[64] + 27
+
+ return nil
+}
+
+func (tx *Transaction) RlpData() interface{} {
+ data := []interface{}{tx.Nonce, tx.GasPrice, tx.Gas, tx.Recipient, tx.Value, tx.Data}
+
+ // TODO Remove prefixing zero's
+
+ return append(data, tx.v, new(big.Int).SetBytes(tx.r).Bytes(), new(big.Int).SetBytes(tx.s).Bytes())
+}
+
+func (tx *Transaction) RlpValue() *ethutil.Value {
+ return ethutil.NewValue(tx.RlpData())
+}
+
+func (tx *Transaction) RlpEncode() []byte {
+ return tx.RlpValue().Encode()
+}
+
+func (tx *Transaction) RlpDecode(data []byte) {
+ tx.RlpValueDecode(ethutil.NewValueFromBytes(data))
+}
+
+func (tx *Transaction) RlpValueDecode(decoder *ethutil.Value) {
+ tx.Nonce = decoder.Get(0).Uint()
+ tx.GasPrice = decoder.Get(1).BigInt()
+ tx.Gas = decoder.Get(2).BigInt()
+ tx.Recipient = decoder.Get(3).Bytes()
+ tx.Value = decoder.Get(4).BigInt()
+ tx.Data = decoder.Get(5).Bytes()
+ tx.v = byte(decoder.Get(6).Uint())
+
+ tx.r = decoder.Get(7).Bytes()
+ tx.s = decoder.Get(8).Bytes()
+
+ if IsContractAddr(tx.Recipient) {
+ tx.contractCreation = true
+ }
+}
+
+func (tx *Transaction) String() string {
+ return fmt.Sprintf(`
+ TX(%x)
+ Contract: %v
+ From: %x
+ To: %x
+ Nonce: %v
+ GasPrice: %v
+ Gas: %v
+ Value: %v
+ Data: 0x%x
+ V: 0x%x
+ R: 0x%x
+ S: 0x%x
+ `,
+ tx.Hash(),
+ len(tx.Recipient) == 0,
+ tx.Sender(),
+ tx.Recipient,
+ tx.Nonce,
+ tx.GasPrice,
+ tx.Gas,
+ tx.Value,
+ tx.Data,
+ tx.v,
+ tx.r,
+ tx.s)
+}
+
+type Receipt struct {
+ Tx *Transaction
+ PostState []byte
+ CumulativeGasUsed *big.Int
+}
+type Receipts []*Receipt
+
+func NewRecieptFromValue(val *ethutil.Value) *Receipt {
+ r := &Receipt{}
+ r.RlpValueDecode(val)
+
+ return r
+}
+
+func (self *Receipt) RlpValueDecode(decoder *ethutil.Value) {
+ self.Tx = NewTransactionFromValue(decoder.Get(0))
+ self.PostState = decoder.Get(1).Bytes()
+ self.CumulativeGasUsed = decoder.Get(2).BigInt()
+}
+
+func (self *Receipt) RlpData() interface{} {
+ return []interface{}{self.Tx.RlpData(), self.PostState, self.CumulativeGasUsed}
+}
+
+func (self *Receipt) String() string {
+ return fmt.Sprintf(`
+ R
+ Tx:[ %v]
+ PostState: 0x%x
+ CumulativeGasUsed: %v
+ `,
+ self.Tx,
+ self.PostState,
+ self.CumulativeGasUsed)
+}
+
+func (self *Receipt) Cmp(other *Receipt) bool {
+ if bytes.Compare(self.PostState, other.PostState) != 0 {
+ return false
+ }
+
+ return true
+}
+
+// Transaction slice type for basic sorting
+type Transactions []*Transaction
+
+func (s Transactions) Len() int { return len(s) }
+func (s Transactions) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
+
+type TxByNonce struct{ Transactions }
+
+func (s TxByNonce) Less(i, j int) bool {
+ return s.Transactions[i].Nonce < s.Transactions[j].Nonce
+}
diff --git a/ethchain/transaction_pool.go b/ethchain/transaction_pool.go
new file mode 100644
index 0000000000000000000000000000000000000000..063688aa8c5938199b646bd7d21b52b721a6553e
--- /dev/null
+++ b/ethchain/transaction_pool.go
@@ -0,0 +1,224 @@
+package ethchain
+
+import (
+ "bytes"
+ "container/list"
+ "fmt"
+ "math/big"
+ "sync"
+
+ "github.com/ethereum/go-ethereum/ethlog"
+ "github.com/ethereum/go-ethereum/ethstate"
+ "github.com/ethereum/go-ethereum/ethwire"
+)
+
+var txplogger = ethlog.NewLogger("TXP")
+
+const (
+ txPoolQueueSize = 50
+)
+
+type TxPoolHook chan *Transaction
+type TxMsgTy byte
+
+const (
+ TxPre = iota
+ TxPost
+
+ minGasPrice = 1000000
+)
+
+var MinGasPrice = big.NewInt(10000000000000)
+
+type TxMsg struct {
+ Tx *Transaction
+ Type TxMsgTy
+}
+
+func FindTx(pool *list.List, finder func(*Transaction, *list.Element) bool) *Transaction {
+ for e := pool.Front(); e != nil; e = e.Next() {
+ if tx, ok := e.Value.(*Transaction); ok {
+ if finder(tx, e) {
+ return tx
+ }
+ }
+ }
+
+ return nil
+}
+
+type TxProcessor interface {
+ ProcessTransaction(tx *Transaction)
+}
+
+// The tx pool a thread safe transaction pool handler. In order to
+// guarantee a non blocking pool we use a queue channel which can be
+// independently read without needing access to the actual pool. If the
+// pool is being drained or synced for whatever reason the transactions
+// will simple queue up and handled when the mutex is freed.
+type TxPool struct {
+ Ethereum EthManager
+ // The mutex for accessing the Tx pool.
+ mutex sync.Mutex
+ // Queueing channel for reading and writing incoming
+ // transactions to
+ queueChan chan *Transaction
+ // Quiting channel
+ quit chan bool
+ // The actual pool
+ pool *list.List
+
+ SecondaryProcessor TxProcessor
+
+ subscribers []chan TxMsg
+}
+
+func NewTxPool(ethereum EthManager) *TxPool {
+ return &TxPool{
+ pool: list.New(),
+ queueChan: make(chan *Transaction, txPoolQueueSize),
+ quit: make(chan bool),
+ Ethereum: ethereum,
+ }
+}
+
+// Blocking function. Don't use directly. Use QueueTransaction instead
+func (pool *TxPool) addTransaction(tx *Transaction) {
+ pool.mutex.Lock()
+ defer pool.mutex.Unlock()
+
+ pool.pool.PushBack(tx)
+
+ // Broadcast the transaction to the rest of the peers
+ pool.Ethereum.Broadcast(ethwire.MsgTxTy, []interface{}{tx.RlpData()})
+}
+
+func (pool *TxPool) ValidateTransaction(tx *Transaction) error {
+ // Get the last block so we can retrieve the sender and receiver from
+ // the merkle trie
+ block := pool.Ethereum.ChainManager().CurrentBlock
+ // Something has gone horribly wrong if this happens
+ if block == nil {
+ return fmt.Errorf("[TXPL] No last block on the block chain")
+ }
+
+ if len(tx.Recipient) != 0 && len(tx.Recipient) != 20 {
+ return fmt.Errorf("[TXPL] Invalid recipient. len = %d", len(tx.Recipient))
+ }
+
+ if tx.GasPrice.Cmp(MinGasPrice) < 0 {
+ return fmt.Errorf("Gas price to low. Require %v > Got %v", MinGasPrice, tx.GasPrice)
+ }
+
+ // Get the sender
+ //sender := pool.Ethereum.StateManager().procState.GetAccount(tx.Sender())
+ sender := pool.Ethereum.StateManager().CurrentState().GetAccount(tx.Sender())
+
+ totAmount := new(big.Int).Set(tx.Value)
+ // Make sure there's enough in the sender's account. Having insufficient
+ // funds won't invalidate this transaction but simple ignores it.
+ if sender.Balance().Cmp(totAmount) < 0 {
+ return fmt.Errorf("[TXPL] Insufficient amount in sender's (%x) account", tx.Sender())
+ }
+
+ if tx.IsContract() {
+ if tx.GasPrice.Cmp(big.NewInt(minGasPrice)) < 0 {
+ return fmt.Errorf("[TXPL] Gasprice too low, %s given should be at least %d.", tx.GasPrice, minGasPrice)
+ }
+ }
+
+ // Increment the nonce making each tx valid only once to prevent replay
+ // attacks
+
+ return nil
+}
+
+func (pool *TxPool) queueHandler() {
+out:
+ for {
+ select {
+ case tx := <-pool.queueChan:
+ hash := tx.Hash()
+ foundTx := FindTx(pool.pool, func(tx *Transaction, e *list.Element) bool {
+ return bytes.Compare(tx.Hash(), hash) == 0
+ })
+
+ if foundTx != nil {
+ break
+ }
+
+ // Validate the transaction
+ err := pool.ValidateTransaction(tx)
+ if err != nil {
+ txplogger.Debugln("Validating Tx failed", err)
+ } else {
+ // Call blocking version.
+ pool.addTransaction(tx)
+
+ tmp := make([]byte, 4)
+ copy(tmp, tx.Recipient)
+
+ txplogger.Debugf("(t) %x => %x (%v) %x\n", tx.Sender()[:4], tmp, tx.Value, tx.Hash())
+
+ // Notify the subscribers
+ pool.Ethereum.EventMux().Post(TxEvent{TxPre, tx})
+ }
+ case <-pool.quit:
+ break out
+ }
+ }
+}
+
+func (pool *TxPool) QueueTransaction(tx *Transaction) {
+ pool.queueChan <- tx
+}
+
+func (pool *TxPool) CurrentTransactions() []*Transaction {
+ pool.mutex.Lock()
+ defer pool.mutex.Unlock()
+
+ txList := make([]*Transaction, pool.pool.Len())
+ i := 0
+ for e := pool.pool.Front(); e != nil; e = e.Next() {
+ tx := e.Value.(*Transaction)
+
+ txList[i] = tx
+
+ i++
+ }
+
+ return txList
+}
+
+func (pool *TxPool) RemoveInvalid(state *ethstate.State) {
+ for e := pool.pool.Front(); e != nil; e = e.Next() {
+ tx := e.Value.(*Transaction)
+ sender := state.GetAccount(tx.Sender())
+ err := pool.ValidateTransaction(tx)
+ if err != nil || sender.Nonce >= tx.Nonce {
+ pool.pool.Remove(e)
+ }
+ }
+}
+
+func (pool *TxPool) Flush() []*Transaction {
+ txList := pool.CurrentTransactions()
+
+ // Recreate a new list all together
+ // XXX Is this the fastest way?
+ pool.pool = list.New()
+
+ return txList
+}
+
+func (pool *TxPool) Start() {
+ go pool.queueHandler()
+}
+
+func (pool *TxPool) Stop() {
+ close(pool.quit)
+
+ pool.Flush()
+
+ txplogger.Infoln("Stopped")
+}
diff --git a/ethchain/transaction_test.go b/ethchain/transaction_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..3603fd8a783708c6afc59213793338cb7f4fcc02
--- /dev/null
+++ b/ethchain/transaction_test.go
@@ -0,0 +1 @@
+package ethchain
diff --git a/ethchain/types.go b/ethchain/types.go
new file mode 100644
index 0000000000000000000000000000000000000000..29084c74996c556b78dacde3c6802eb16f18c16f
--- /dev/null
+++ b/ethchain/types.go
@@ -0,0 +1,312 @@
+package ethchain
+
+import (
+ "fmt"
+)
+
+type OpCode int
+
+// Op codes
+const (
+ // 0x0 range - arithmetic ops
+ STOP = 0x00
+ ADD = 0x01
+ MUL = 0x02
+ SUB = 0x03
+ DIV = 0x04
+ SDIV = 0x05
+ MOD = 0x06
+ SMOD = 0x07
+ EXP = 0x08
+ NEG = 0x09
+ LT = 0x0a
+ GT = 0x0b
+ SLT = 0x0c
+ SGT = 0x0d
+ EQ = 0x0e
+ NOT = 0x0f
+
+ // 0x10 range - bit ops
+ AND = 0x10
+ OR = 0x11
+ XOR = 0x12
+ BYTE = 0x13
+ ADDMOD = 0x14
+ MULMOD = 0x15
+
+ // 0x20 range - crypto
+ SHA3 = 0x20
+
+ // 0x30 range - closure state
+ ADDRESS = 0x30
+ BALANCE = 0x31
+ ORIGIN = 0x32
+ CALLER = 0x33
+ CALLVALUE = 0x34
+ CALLDATALOAD = 0x35
+ CALLDATASIZE = 0x36
+ CALLDATACOPY = 0x37
+ CODESIZE = 0x38
+ CODECOPY = 0x39
+ GASPRICE = 0x3a
+ EXTCODESIZE = 0x3b
+ EXTCODECOPY = 0x3c
+
+ // 0x40 range - block operations
+ PREVHASH = 0x40
+ COINBASE = 0x41
+ TIMESTAMP = 0x42
+ NUMBER = 0x43
+ DIFFICULTY = 0x44
+ GASLIMIT = 0x45
+
+ // 0x50 range - 'storage' and execution
+ POP = 0x50
+ //DUP = 0x51
+ //SWAP = 0x52
+ MLOAD = 0x53
+ MSTORE = 0x54
+ MSTORE8 = 0x55
+ SLOAD = 0x56
+ SSTORE = 0x57
+ JUMP = 0x58
+ JUMPI = 0x59
+ PC = 0x5a
+ MSIZE = 0x5b
+ GAS = 0x5c
+
+ // 0x60 range
+ PUSH1 = 0x60
+ PUSH2 = 0x61
+ PUSH3 = 0x62
+ PUSH4 = 0x63
+ PUSH5 = 0x64
+ PUSH6 = 0x65
+ PUSH7 = 0x66
+ PUSH8 = 0x67
+ PUSH9 = 0x68
+ PUSH10 = 0x69
+ PUSH11 = 0x6a
+ PUSH12 = 0x6b
+ PUSH13 = 0x6c
+ PUSH14 = 0x6d
+ PUSH15 = 0x6e
+ PUSH16 = 0x6f
+ PUSH17 = 0x70
+ PUSH18 = 0x71
+ PUSH19 = 0x72
+ PUSH20 = 0x73
+ PUSH21 = 0x74
+ PUSH22 = 0x75
+ PUSH23 = 0x76
+ PUSH24 = 0x77
+ PUSH25 = 0x78
+ PUSH26 = 0x79
+ PUSH27 = 0x7a
+ PUSH28 = 0x7b
+ PUSH29 = 0x7c
+ PUSH30 = 0x7d
+ PUSH31 = 0x7e
+ PUSH32 = 0x7f
+
+ DUP1 = 0x80
+ DUP2 = 0x81
+ DUP3 = 0x82
+ DUP4 = 0x83
+ DUP5 = 0x84
+ DUP6 = 0x85
+ DUP7 = 0x86
+ DUP8 = 0x87
+ DUP9 = 0x88
+ DUP10 = 0x89
+ DUP11 = 0x8a
+ DUP12 = 0x8b
+ DUP13 = 0x8c
+ DUP14 = 0x8d
+ DUP15 = 0x8e
+ DUP16 = 0x8f
+
+ SWAP1 = 0x90
+ SWAP2 = 0x91
+ SWAP3 = 0x92
+ SWAP4 = 0x93
+ SWAP5 = 0x94
+ SWAP6 = 0x95
+ SWAP7 = 0x96
+ SWAP8 = 0x97
+ SWAP9 = 0x98
+ SWAP10 = 0x99
+ SWAP11 = 0x9a
+ SWAP12 = 0x9b
+ SWAP13 = 0x9c
+ SWAP14 = 0x9d
+ SWAP15 = 0x9e
+ SWAP16 = 0x9f
+
+ // 0xf0 range - closures
+ CREATE = 0xf0
+ CALL = 0xf1
+ RETURN = 0xf2
+ CALLCODE = 0xf3
+
+ // 0x70 range - other
+ LOG = 0xfe // XXX Unofficial
+ SUICIDE = 0xff
+)
+
+// Since the opcodes aren't all in order we can't use a regular slice
+var opCodeToString = map[OpCode]string{
+ // 0x0 range - arithmetic ops
+ STOP: "STOP",
+ ADD: "ADD",
+ MUL: "MUL",
+ SUB: "SUB",
+ DIV: "DIV",
+ SDIV: "SDIV",
+ MOD: "MOD",
+ SMOD: "SMOD",
+ EXP: "EXP",
+ NEG: "NEG",
+ LT: "LT",
+ GT: "GT",
+ SLT: "SLT",
+ SGT: "SGT",
+ EQ: "EQ",
+ NOT: "NOT",
+
+ // 0x10 range - bit ops
+ AND: "AND",
+ OR: "OR",
+ XOR: "XOR",
+ BYTE: "BYTE",
+ ADDMOD: "ADDMOD",
+ MULMOD: "MULMOD",
+
+ // 0x20 range - crypto
+ SHA3: "SHA3",
+
+ // 0x30 range - closure state
+ ADDRESS: "ADDRESS",
+ BALANCE: "BALANCE",
+ ORIGIN: "ORIGIN",
+ CALLER: "CALLER",
+ CALLVALUE: "CALLVALUE",
+ CALLDATALOAD: "CALLDATALOAD",
+ CALLDATASIZE: "CALLDATASIZE",
+ CALLDATACOPY: "CALLDATACOPY",
+ CODESIZE: "CODESIZE",
+ CODECOPY: "CODECOPY",
+ GASPRICE: "TXGASPRICE",
+
+ // 0x40 range - block operations
+ PREVHASH: "PREVHASH",
+ COINBASE: "COINBASE",
+ TIMESTAMP: "TIMESTAMP",
+ NUMBER: "NUMBER",
+ DIFFICULTY: "DIFFICULTY",
+ GASLIMIT: "GASLIMIT",
+ EXTCODESIZE: "EXTCODESIZE",
+ EXTCODECOPY: "EXTCODECOPY",
+
+ // 0x50 range - 'storage' and execution
+ POP: "POP",
+ //DUP: "DUP",
+ //SWAP: "SWAP",
+ MLOAD: "MLOAD",
+ MSTORE: "MSTORE",
+ MSTORE8: "MSTORE8",
+ SLOAD: "SLOAD",
+ SSTORE: "SSTORE",
+ JUMP: "JUMP",
+ JUMPI: "JUMPI",
+ PC: "PC",
+ MSIZE: "MSIZE",
+ GAS: "GAS",
+
+ // 0x60 range - push
+ PUSH1: "PUSH1",
+ PUSH2: "PUSH2",
+ PUSH3: "PUSH3",
+ PUSH4: "PUSH4",
+ PUSH5: "PUSH5",
+ PUSH6: "PUSH6",
+ PUSH7: "PUSH7",
+ PUSH8: "PUSH8",
+ PUSH9: "PUSH9",
+ PUSH10: "PUSH10",
+ PUSH11: "PUSH11",
+ PUSH12: "PUSH12",
+ PUSH13: "PUSH13",
+ PUSH14: "PUSH14",
+ PUSH15: "PUSH15",
+ PUSH16: "PUSH16",
+ PUSH17: "PUSH17",
+ PUSH18: "PUSH18",
+ PUSH19: "PUSH19",
+ PUSH20: "PUSH20",
+ PUSH21: "PUSH21",
+ PUSH22: "PUSH22",
+ PUSH23: "PUSH23",
+ PUSH24: "PUSH24",
+ PUSH25: "PUSH25",
+ PUSH26: "PUSH26",
+ PUSH27: "PUSH27",
+ PUSH28: "PUSH28",
+ PUSH29: "PUSH29",
+ PUSH30: "PUSH30",
+ PUSH31: "PUSH31",
+ PUSH32: "PUSH32",
+
+ DUP1: "DUP1",
+ DUP2: "DUP2",
+ DUP3: "DUP3",
+ DUP4: "DUP4",
+ DUP5: "DUP5",
+ DUP6: "DUP6",
+ DUP7: "DUP7",
+ DUP8: "DUP8",
+ DUP9: "DUP9",
+ DUP10: "DUP10",
+ DUP11: "DUP11",
+ DUP12: "DUP12",
+ DUP13: "DUP13",
+ DUP14: "DUP14",
+ DUP15: "DUP15",
+ DUP16: "DUP16",
+
+ SWAP1: "SWAP1",
+ SWAP2: "SWAP2",
+ SWAP3: "SWAP3",
+ SWAP4: "SWAP4",
+ SWAP5: "SWAP5",
+ SWAP6: "SWAP6",
+ SWAP7: "SWAP7",
+ SWAP8: "SWAP8",
+ SWAP9: "SWAP9",
+ SWAP10: "SWAP10",
+ SWAP11: "SWAP11",
+ SWAP12: "SWAP12",
+ SWAP13: "SWAP13",
+ SWAP14: "SWAP14",
+ SWAP15: "SWAP15",
+ SWAP16: "SWAP16",
+
+ // 0xf0 range
+ CREATE: "CREATE",
+ CALL: "CALL",
+ RETURN: "RETURN",
+ CALLCODE: "CALLCODE",
+
+ // 0x70 range - other
+ LOG: "LOG",
+ SUICIDE: "SUICIDE",
+}
+
+func (o OpCode) String() string {
+ str := opCodeToString[o]
+ if len(str) == 0 {
+ return fmt.Sprintf("Missing opcode 0x%x", int(o))
+ }
+
+ return str
+}
diff --git a/ethchain/vm_env.go b/ethchain/vm_env.go
new file mode 100644
index 0000000000000000000000000000000000000000..6dda27c6f84c03fc02825e4ccdcca60f406993c0
--- /dev/null
+++ b/ethchain/vm_env.go
@@ -0,0 +1,36 @@
+package ethchain
+
+import (
+ "math/big"
+
+ "github.com/ethereum/go-ethereum/ethstate"
+ "github.com/ethereum/go-ethereum/vm"
+)
+
+type VMEnv struct {
+ state *ethstate.State
+ block *Block
+ tx *Transaction
+}
+
+func NewEnv(state *ethstate.State, tx *Transaction, block *Block) *VMEnv {
+ return &VMEnv{
+ state: state,
+ block: block,
+ tx: tx,
+ }
+}
+
+func (self *VMEnv) Origin() []byte { return self.tx.Sender() }
+func (self *VMEnv) BlockNumber() *big.Int { return self.block.Number }
+func (self *VMEnv) PrevHash() []byte { return self.block.PrevHash }
+func (self *VMEnv) Coinbase() []byte { return self.block.Coinbase }
+func (self *VMEnv) Time() int64 { return self.block.Time }
+func (self *VMEnv) Difficulty() *big.Int { return self.block.Difficulty }
+func (self *VMEnv) BlockHash() []byte { return self.block.Hash() }
+func (self *VMEnv) Value() *big.Int { return self.tx.Value }
+func (self *VMEnv) State() *ethstate.State { return self.state }
+func (self *VMEnv) GasLimit() *big.Int { return self.block.GasLimit }
+func (self *VMEnv) Transfer(from, to vm.Account, amount *big.Int) error {
+ return vm.Transfer(from, to, amount)
+}
diff --git a/ethcrypto/crypto.go b/ethcrypto/crypto.go
new file mode 100644
index 0000000000000000000000000000000000000000..068e066d549b94d902d291562a3459bd6b474fb4
--- /dev/null
+++ b/ethcrypto/crypto.go
@@ -0,0 +1,47 @@
+package ethcrypto
+
+import (
+ "crypto/sha256"
+
+ "code.google.com/p/go.crypto/ripemd160"
+ "github.com/ethereum/go-ethereum/ethutil"
+ "github.com/obscuren/secp256k1-go"
+ "github.com/obscuren/sha3"
+)
+
+// TODO refactor, remove (bin)
+func Sha3(data []byte) []byte {
+ d := sha3.NewKeccak256()
+ d.Write(data)
+
+ return d.Sum(nil)
+}
+
+// Creates an ethereum address given the bytes and the nonce
+func CreateAddress(b []byte, nonce uint64) []byte {
+ return Sha3(ethutil.NewValue([]interface{}{b, nonce}).Encode())[12:]
+}
+
+func Sha256(data []byte) []byte {
+ hash := sha256.Sum256(data)
+
+ return hash[:]
+}
+
+func Ripemd160(data []byte) []byte {
+ ripemd := ripemd160.New()
+ ripemd.Write(data)
+
+ return ripemd.Sum(nil)
+}
+
+func Ecrecover(data []byte) []byte {
+ var in = struct {
+ hash []byte
+ sig []byte
+ }{data[:32], data[32:]}
+
+ r, _ := secp256k1.RecoverPubkey(in.hash, in.sig)
+
+ return r
+}
diff --git a/ethcrypto/crypto_test.go b/ethcrypto/crypto_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..689bcecb44bcd6c50bad710d59fe0fc0c7660ddd
--- /dev/null
+++ b/ethcrypto/crypto_test.go
@@ -0,0 +1,17 @@
+package ethcrypto
+
+import (
+ "bytes"
+ "testing"
+
+ "github.com/ethereum/go-ethereum/ethutil"
+)
+
+// FIPS 202 test (reverted back to FIPS 180)
+func TestSha3(t *testing.T) {
+ const exp = "3a985da74fe225b2045c172d6bd390bd855f086e3e9d525b46bfe24511431532"
+ sha3_256 := Sha3Bin([]byte("abc"))
+ if bytes.Compare(sha3_256, ethutil.Hex2Bytes(exp)) != 0 {
+ t.Errorf("Sha3_256 failed. Incorrect result %x", sha3_256)
+ }
+}
diff --git a/ethcrypto/key_manager.go b/ethcrypto/key_manager.go
new file mode 100644
index 0000000000000000000000000000000000000000..109768423f80ce9cf69f6e164944021cc62df2c1
--- /dev/null
+++ b/ethcrypto/key_manager.go
@@ -0,0 +1,130 @@
+package ethcrypto
+
+import (
+ "fmt"
+ "sync"
+
+ "github.com/ethereum/go-ethereum/ethutil"
+)
+
+type KeyManager struct {
+ keyRing *KeyRing
+ session string
+ keyStore KeyStore // interface
+ keyRings map[string]*KeyRing // cache
+ keyPair *KeyPair
+}
+
+func NewDBKeyManager(db ethutil.Database) *KeyManager {
+ return &KeyManager{keyStore: &DBKeyStore{db: db}, keyRings: make(map[string]*KeyRing)}
+}
+
+func NewFileKeyManager(basedir string) *KeyManager {
+ return &KeyManager{keyStore: &FileKeyStore{basedir: basedir}, keyRings: make(map[string]*KeyRing)}
+}
+
+func (k *KeyManager) KeyPair() *KeyPair {
+ return k.keyPair
+}
+
+func (k *KeyManager) KeyRing() *KeyPair {
+ return k.keyPair
+}
+
+func (k *KeyManager) PrivateKey() []byte {
+ return k.keyPair.PrivateKey
+}
+
+func (k *KeyManager) PublicKey() []byte {
+ return k.keyPair.PublicKey
+}
+
+func (k *KeyManager) Address() []byte {
+ return k.keyPair.Address()
+}
+
+func (k *KeyManager) save(session string, keyRing *KeyRing) error {
+ err := k.keyStore.Save(session, keyRing)
+ if err != nil {
+ return err
+ }
+ k.keyRings[session] = keyRing
+ return nil
+}
+
+func (k *KeyManager) load(session string) (*KeyRing, error) {
+ keyRing, found := k.keyRings[session]
+ if !found {
+ var err error
+ keyRing, err = k.keyStore.Load(session)
+ if err != nil {
+ return nil, err
+ }
+ }
+ return keyRing, nil
+}
+
+func cursorError(cursor int, len int) error {
+ return fmt.Errorf("cursor %d out of range (0..%d)", cursor, len)
+}
+
+func (k *KeyManager) reset(session string, cursor int, keyRing *KeyRing) error {
+ if cursor >= keyRing.Len() {
+ return cursorError(cursor, keyRing.Len())
+ }
+ lock := &sync.Mutex{}
+ lock.Lock()
+ defer lock.Unlock()
+ err := k.save(session, keyRing)
+ if err != nil {
+ return err
+ }
+ k.session = session
+ k.keyRing = keyRing
+ k.keyPair = keyRing.GetKeyPair(cursor)
+ return nil
+}
+
+func (k *KeyManager) SetCursor(cursor int) error {
+ if cursor >= k.keyRing.Len() {
+ return cursorError(cursor, k.keyRing.Len())
+ }
+ k.keyPair = k.keyRing.GetKeyPair(cursor)
+ return nil
+}
+
+func (k *KeyManager) Init(session string, cursor int, force bool) error {
+ var keyRing *KeyRing
+ if !force {
+ var err error
+ keyRing, err = k.load(session)
+ if err != nil {
+ return err
+ }
+ }
+ if keyRing == nil {
+ keyRing = NewGeneratedKeyRing(1)
+ }
+ return k.reset(session, cursor, keyRing)
+}
+
+func (k *KeyManager) InitFromSecretsFile(session string, cursor int, secretsfile string) error {
+ keyRing, err := NewKeyRingFromFile(secretsfile)
+ if err != nil {
+ return err
+ }
+ return k.reset(session, cursor, keyRing)
+}
+
+func (k *KeyManager) InitFromString(session string, cursor int, secrets string) error {
+ keyRing, err := NewKeyRingFromString(secrets)
+ if err != nil {
+ return err
+ }
+ return k.reset(session, cursor, keyRing)
+}
+
+func (k *KeyManager) Export(dir string) error {
+ fileKeyStore := FileKeyStore{dir}
+ return fileKeyStore.Save(k.session, k.keyRing)
+}
diff --git a/ethcrypto/key_store.go b/ethcrypto/key_store.go
new file mode 100644
index 0000000000000000000000000000000000000000..14d11011fec14700dde280c050520e6fb4a58bea
--- /dev/null
+++ b/ethcrypto/key_store.go
@@ -0,0 +1,113 @@
+package ethcrypto
+
+import (
+ "fmt"
+ "io/ioutil"
+ "os"
+ "path"
+ "strings"
+
+ "github.com/ethereum/go-ethereum/ethutil"
+)
+
+type KeyStore interface {
+ Load(string) (*KeyRing, error)
+ Save(string, *KeyRing) error
+}
+
+type DBKeyStore struct {
+ db ethutil.Database
+}
+
+const dbKeyPrefix = "KeyRing"
+
+func (k *DBKeyStore) dbKey(session string) []byte {
+ return []byte(fmt.Sprintf("%s%s", dbKeyPrefix, session))
+}
+
+func (k *DBKeyStore) Save(session string, keyRing *KeyRing) error {
+ k.db.Put(k.dbKey(session), keyRing.RlpEncode())
+ return nil
+}
+
+func (k *DBKeyStore) Load(session string) (*KeyRing, error) {
+ data, err := k.db.Get(k.dbKey(session))
+ if err != nil {
+ return nil, nil
+ }
+ var keyRing *KeyRing
+ keyRing, err = NewKeyRingFromBytes(data)
+ if err != nil {
+ return nil, err
+ }
+ // if empty keyRing is found we return nil, no error
+ if keyRing.Len() == 0 {
+ return nil, nil
+ }
+ return keyRing, nil
+}
+
+type FileKeyStore struct {
+ basedir string
+}
+
+func (k *FileKeyStore) Save(session string, keyRing *KeyRing) error {
+ var content []byte
+ var err error
+ var privateKeys []string
+ var publicKeys []string
+ var mnemonics []string
+ var addresses []string
+ keyRing.Each(func(keyPair *KeyPair) {
+ privateKeys = append(privateKeys, ethutil.Bytes2Hex(keyPair.PrivateKey))
+ publicKeys = append(publicKeys, ethutil.Bytes2Hex(keyPair.PublicKey))
+ addresses = append(addresses, ethutil.Bytes2Hex(keyPair.Address()))
+ mnemonics = append(mnemonics, keyPair.Mnemonic())
+ })
+
+ basename := session
+ if session == "" {
+ basename = "default"
+ }
+
+ path := path.Join(k.basedir, basename)
+ content = []byte(strings.Join(privateKeys, "\n"))
+ err = ioutil.WriteFile(path+".prv", content, 0600)
+ if err != nil {
+ return err
+ }
+
+ content = []byte(strings.Join(publicKeys, "\n"))
+ err = ioutil.WriteFile(path+".pub", content, 0644)
+ if err != nil {
+ return err
+ }
+
+ content = []byte(strings.Join(addresses, "\n"))
+ err = ioutil.WriteFile(path+".addr", content, 0644)
+ if err != nil {
+ return err
+ }
+
+ content = []byte(strings.Join(mnemonics, "\n"))
+ err = ioutil.WriteFile(path+".mne", content, 0600)
+ if err != nil {
+ return err
+ }
+
+ return nil
+}
+
+func (k *FileKeyStore) Load(session string) (*KeyRing, error) {
+ basename := session
+ if session == "" {
+ basename = "default"
+ }
+ secfile := path.Join(k.basedir, basename+".prv")
+ _, err := os.Stat(secfile)
+ // if file is not found then we return nil, no error
+ if err != nil {
+ return nil, nil
+ }
+ return NewKeyRingFromFile(secfile)
+}
diff --git a/ethcrypto/keypair.go b/ethcrypto/keypair.go
new file mode 100644
index 0000000000000000000000000000000000000000..613f65d8c72606c2d76021eed65ad8909535e235
--- /dev/null
+++ b/ethcrypto/keypair.go
@@ -0,0 +1,58 @@
+package ethcrypto
+
+import (
+ "strings"
+
+ "github.com/ethereum/go-ethereum/ethutil"
+ "github.com/obscuren/secp256k1-go"
+)
+
+type KeyPair struct {
+ PrivateKey []byte
+ PublicKey []byte
+ address []byte
+ mnemonic string
+ // The associated account
+ // account *StateObject
+}
+
+func GenerateNewKeyPair() *KeyPair {
+ _, prv := secp256k1.GenerateKeyPair()
+ keyPair, _ := NewKeyPairFromSec(prv) // swallow error, this one cannot err
+ return keyPair
+}
+
+func NewKeyPairFromSec(seckey []byte) (*KeyPair, error) {
+ pubkey, err := secp256k1.GeneratePubKey(seckey)
+ if err != nil {
+ return nil, err
+ }
+
+ return &KeyPair{PrivateKey: seckey, PublicKey: pubkey}, nil
+}
+
+func (k *KeyPair) Address() []byte {
+ if k.address == nil {
+ k.address = Sha3(k.PublicKey[1:])[12:]
+ }
+ return k.address
+}
+
+func (k *KeyPair) Mnemonic() string {
+ if k.mnemonic == "" {
+ k.mnemonic = strings.Join(MnemonicEncode(ethutil.Bytes2Hex(k.PrivateKey)), " ")
+ }
+ return k.mnemonic
+}
+
+func (k *KeyPair) AsStrings() (string, string, string, string) {
+ return k.Mnemonic(), ethutil.Bytes2Hex(k.Address()), ethutil.Bytes2Hex(k.PrivateKey), ethutil.Bytes2Hex(k.PublicKey)
+}
+
+func (k *KeyPair) RlpEncode() []byte {
+ return k.RlpValue().Encode()
+}
+
+func (k *KeyPair) RlpValue() *ethutil.Value {
+ return ethutil.NewValue(k.PrivateKey)
+}
diff --git a/ethcrypto/keyring.go b/ethcrypto/keyring.go
new file mode 100644
index 0000000000000000000000000000000000000000..35733808b3c044309cf7ee10cef0e42edcbcea69
--- /dev/null
+++ b/ethcrypto/keyring.go
@@ -0,0 +1,123 @@
+package ethcrypto
+
+import (
+ "fmt"
+ "io/ioutil"
+ "strings"
+
+ "github.com/ethereum/go-ethereum/ethutil"
+)
+
+type KeyRing struct {
+ keys []*KeyPair
+}
+
+func NewKeyRing() *KeyRing {
+ return &KeyRing{}
+}
+
+func (k *KeyRing) AddKeyPair(keyPair *KeyPair) {
+ k.keys = append(k.keys, keyPair)
+}
+
+func (k *KeyRing) GetKeyPair(i int) *KeyPair {
+ if len(k.keys) > i {
+ return k.keys[i]
+ }
+
+ return nil
+}
+
+func (k *KeyRing) Empty() bool {
+ return k.Len() == 0
+}
+
+func (k *KeyRing) Len() int {
+ return len(k.keys)
+}
+
+func (k *KeyRing) Each(f func(*KeyPair)) {
+ for _, keyPair := range k.keys {
+ f(keyPair)
+ }
+}
+
+func NewGeneratedKeyRing(len int) *KeyRing {
+ keyRing := NewKeyRing()
+ for i := 0; i < len; i++ {
+ keyRing.AddKeyPair(GenerateNewKeyPair())
+ }
+ return keyRing
+}
+
+func NewKeyRingFromFile(secfile string) (*KeyRing, error) {
+ var content []byte
+ var err error
+ content, err = ioutil.ReadFile(secfile)
+ if err != nil {
+ return nil, err
+ }
+ keyRing, err := NewKeyRingFromString(string(content))
+ if err != nil {
+ return nil, err
+ }
+ return keyRing, nil
+}
+
+func NewKeyRingFromString(content string) (*KeyRing, error) {
+ secretStrings := strings.Split(content, "\n")
+ var secrets [][]byte
+ for _, secretString := range secretStrings {
+ secret := secretString
+ words := strings.Split(secretString, " ")
+ if len(words) == 24 {
+ secret = MnemonicDecode(words)
+ } else if len(words) != 1 {
+ return nil, fmt.Errorf("Unrecognised key format")
+ }
+
+ if len(secret) != 0 {
+ secrets = append(secrets, ethutil.Hex2Bytes(secret))
+ }
+ }
+
+ return NewKeyRingFromSecrets(secrets)
+}
+
+func NewKeyRingFromSecrets(secs [][]byte) (*KeyRing, error) {
+ keyRing := NewKeyRing()
+ for _, sec := range secs {
+ keyPair, err := NewKeyPairFromSec(sec)
+ if err != nil {
+ return nil, err
+ }
+ keyRing.AddKeyPair(keyPair)
+ }
+ return keyRing, nil
+}
+
+func NewKeyRingFromBytes(data []byte) (*KeyRing, error) {
+ var secrets [][]byte
+ it := ethutil.NewValueFromBytes(data).NewIterator()
+ for it.Next() {
+ secret := it.Value().Bytes()
+ secrets = append(secrets, secret)
+ }
+ keyRing, err := NewKeyRingFromSecrets(secrets)
+ if err != nil {
+ return nil, err
+ }
+ return keyRing, nil
+}
+
+func (k *KeyRing) RlpEncode() []byte {
+ return k.RlpValue().Encode()
+}
+
+func (k *KeyRing) RlpValue() *ethutil.Value {
+ v := ethutil.EmptyValue()
+ k.Each(func(keyPair *KeyPair) {
+ v.Append(keyPair.RlpValue())
+ })
+ return v
+}
diff --git a/ethcrypto/keys_test.go b/ethcrypto/keys_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..8aedc1ee188ffacbf5f2dbbd001bf75eafc570a6
--- /dev/null
+++ b/ethcrypto/keys_test.go
@@ -0,0 +1,122 @@
+package ethcrypto
+
+import (
+ "github.com/ethereum/go-ethereum/ethdb"
+ // "io/ioutil"
+ "fmt"
+ "os"
+ "path"
+ "testing"
+)
+
+// test if persistence layer works
+func TestDBKeyManager(t *testing.T) {
+ memdb, _ := ethdb.NewMemDatabase()
+ keyManager0 := NewDBKeyManager(memdb)
+ err := keyManager0.Init("", 0, false)
+ if err != nil {
+ t.Error("Unexpected error: ", err)
+ }
+ keyManager1 := NewDBKeyManager(memdb)
+ err = keyManager1.Init("", 0, false)
+ if err != nil {
+ t.Error("Unexpected error: ", err)
+ }
+ if string(keyManager0.PrivateKey()) != string(keyManager1.PrivateKey()) {
+ t.Error("Expected private keys %x, %x, to be identical via db persistence", keyManager0.PrivateKey(), keyManager1.PrivateKey())
+ }
+ err = keyManager1.Init("", 0, true)
+ if err != nil {
+ t.Error("Unexpected error: ", err)
+ }
+ if string(keyManager0.PrivateKey()) == string(keyManager1.PrivateKey()) {
+ t.Error("Expected private keys %x, %x, to be be different despite db persistence if force generate", keyManager0.PrivateKey(), keyManager1.PrivateKey())
+ }
+}
+
+func TestFileKeyManager(t *testing.T) {
+ basedir0 := "/tmp/ethtest0"
+ os.RemoveAll(basedir0)
+ os.Mkdir(basedir0, 0777)
+
+ keyManager0 := NewFileKeyManager(basedir0)
+ err := keyManager0.Init("", 0, false)
+ if err != nil {
+ t.Error("Unexpected error: ", err)
+ }
+
+ keyManager1 := NewFileKeyManager(basedir0)
+
+ err = keyManager1.Init("", 0, false)
+ if err != nil {
+ t.Error("Unexpected error: ", err)
+ }
+ if string(keyManager0.PrivateKey()) != string(keyManager1.PrivateKey()) {
+ t.Error("Expected private keys %x, %x, to be identical via db persistence", keyManager0.PrivateKey(), keyManager1.PrivateKey())
+ }
+
+ err = keyManager1.Init("", 0, true)
+ if err != nil {
+ t.Error("Unexpected error: ", err)
+ }
+ if string(keyManager0.PrivateKey()) == string(keyManager1.PrivateKey()) {
+ t.Error("Expected private keys %x, %x, to be be different despite db persistence if force generate", keyManager0.PrivateKey(), keyManager1.PrivateKey())
+ }
+}
+
+// cursor errors
+func TestCursorErrors(t *testing.T) {
+ memdb, _ := ethdb.NewMemDatabase()
+ keyManager0 := NewDBKeyManager(memdb)
+ err := keyManager0.Init("", 0, false)
+ err = keyManager0.Init("", 1, false)
+ if err == nil {
+ t.Error("Expected cursor error")
+ }
+ err = keyManager0.SetCursor(1)
+ if err == nil {
+ t.Error("Expected cursor error")
+ }
+}
+
+func TestExportImport(t *testing.T) {
+ memdb, _ := ethdb.NewMemDatabase()
+ keyManager0 := NewDBKeyManager(memdb)
+ err := keyManager0.Init("", 0, false)
+ basedir0 := "/tmp/ethtest0"
+ os.RemoveAll(basedir0)
+ os.Mkdir(basedir0, 0777)
+ keyManager0.Export(basedir0)
+
+ keyManager1 := NewFileKeyManager(basedir0)
+ err = keyManager1.Init("", 0, false)
+ if err != nil {
+ t.Error("Unexpected error: ", err)
+ }
+ fmt.Printf("keyRing: %v\n", keyManager0.KeyPair())
+ fmt.Printf("keyRing: %v\n", keyManager1.KeyPair())
+ if string(keyManager0.PrivateKey()) != string(keyManager1.PrivateKey()) {
+ t.Error("Expected private keys %x, %x, to be identical via export to filestore basedir", keyManager0.PrivateKey(), keyManager1.PrivateKey())
+ }
+ path.Join("")
+
+ // memdb, _ = ethdb.NewMemDatabase()
+ // keyManager2 := NewDBKeyManager(memdb)
+ // err = keyManager2.InitFromSecretsFile("", 0, path.Join(basedir0, "default.prv"))
+ // if err != nil {
+ // t.Error("Unexpected error: ", err)
+ // }
+ // if string(keyManager0.PrivateKey()) != string(keyManager2.PrivateKey()) {
+ // t.Error("Expected private keys %s, %s, to be identical via export/import prv", keyManager0.PrivateKey(), keyManager1.PrivateKey())
+ // }
+
+ // memdb, _ = ethdb.NewMemDatabase()
+ // keyManager3 := NewDBKeyManager(memdb)
+ // err = keyManager3.InitFromSecretsFile("", 0, path.Join(basedir0, "default.mne"))
+ // if err != nil {
+ // t.Error("Unexpected error: ", err)
+ // }
+ // if string(keyManager0.PrivateKey()) != string(keyManager3.PrivateKey()) {
+ // t.Error("Expected private keys %s, %s, to be identical via export/import mnemonic file", keyManager0.PrivateKey(), keyManager1.PrivateKey())
+ // }
+}
diff --git a/ethcrypto/mnemonic.go b/ethcrypto/mnemonic.go
new file mode 100644
index 0000000000000000000000000000000000000000..5fb6202191a2d514f1025adfd588394546f1b010
--- /dev/null
+++ b/ethcrypto/mnemonic.go
@@ -0,0 +1,60 @@
+package ethcrypto
+
+import (
+ "fmt"
+ "strconv"
+)
+
+// TODO: See if we can refactor this into a shared util lib if we need it multiple times
+func IndexOf(slice []string, value string) int64 {
+ for p, v := range slice {
+ if v == value {
+ return int64(p)
+ }
+ }
+ return -1
+}
+
+func MnemonicEncode(message string) []string {
+ var out []string
+ n := int64(len(MnemonicWords))
+
+ for i := 0; i < len(message); i += (len(message) / 8) {
+ x := message[i : i+8]
+ bit, _ := strconv.ParseInt(x, 16, 64)
+ w1 := (bit % n)
+ w2 := ((bit / n) + w1) % n
+ w3 := ((bit / n / n) + w2) % n
+ out = append(out, MnemonicWords[w1], MnemonicWords[w2], MnemonicWords[w3])
+ }
+ return out
+}
+
+func MnemonicDecode(wordsar []string) string {
+ var out string
+ n := int64(len(MnemonicWords))
+
+ for i := 0; i < len(wordsar); i += 3 {
+ word1 := wordsar[i]
+ word2 := wordsar[i+1]
+ word3 := wordsar[i+2]
+ w1 := IndexOf(MnemonicWords, word1)
+ w2 := IndexOf(MnemonicWords, word2)
+ w3 := IndexOf(MnemonicWords, word3)
+
+ y := (w2 - w1) % n
+ z := (w3 - w2) % n
+
+ // Golang handles modulo with negative numbers different then most languages
+ // The modulo can be negative, we don't want that.
+ if z < 0 {
+ z += n
+ }
+ if y < 0 {
+ y += n
+ }
+ x := w1 + n*(y) + n*n*(z)
+ out += fmt.Sprintf("%08x", x)
+ }
+ return out
+}
diff --git a/ethcrypto/mnemonic_test.go b/ethcrypto/mnemonic_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..8bd8859ae3fee4df8ff0c112c309a8622991bd94
--- /dev/null
+++ b/ethcrypto/mnemonic_test.go
@@ -0,0 +1,74 @@
+package ethcrypto
+
+import (
+ "testing"
+)
+
+func TestMnDecode(t *testing.T) {
+ words := []string{
+ "ink",
+ "balance",
+ "gain",
+ "fear",
+ "happen",
+ "melt",
+ "mom",
+ "surface",
+ "stir",
+ "bottle",
+ "unseen",
+ "expression",
+ "important",
+ "curl",
+ "grant",
+ "fairy",
+ "across",
+ "back",
+ "figure",
+ "breast",
+ "nobody",
+ "scratch",
+ "worry",
+ "yesterday",
+ }
+ encode := "c61d43dc5bb7a4e754d111dae8105b6f25356492df5e50ecb33b858d94f8c338"
+ result := MnemonicDecode(words)
+ if encode != result {
+ t.Error("We expected", encode, "got", result, "instead")
+ }
+}
+func TestMnEncode(t *testing.T) {
+ encode := "c61d43dc5bb7a4e754d111dae8105b6f25356492df5e50ecb33b858d94f8c338"
+ result := []string{
+ "ink",
+ "balance",
+ "gain",
+ "fear",
+ "happen",
+ "melt",
+ "mom",
+ "surface",
+ "stir",
+ "bottle",
+ "unseen",
+ "expression",
+ "important",
+ "curl",
+ "grant",
+ "fairy",
+ "across",
+ "back",
+ "figure",
+ "breast",
+ "nobody",
+ "scratch",
+ "worry",
+ "yesterday",
+ }
+ words := MnemonicEncode(encode)
+ for i, word := range words {
+ if word != result[i] {
+ t.Error("Mnenonic does not match:", words, result)
+ }
+ }
+}
diff --git a/ethcrypto/mnemonic_words.go b/ethcrypto/mnemonic_words.go
new file mode 100644
index 0000000000000000000000000000000000000000..72f0ad48fd9c9f1e86d66ab7ce7b6b31a216b828
--- /dev/null
+++ b/ethcrypto/mnemonic_words.go
@@ -0,0 +1,1630 @@
+package ethcrypto
+
+var MnemonicWords []string = []string{
+ "like",
+ "just",
+ "love",
+ "know",
+ "never",
+ "want",
+ "time",
+ "out",
+ "there",
+ "make",
+ "look",
+ "eye",
+ "down",
+ "only",
+ "think",
+ "heart",
+ "back",
+ "then",
+ "into",
+ "about",
+ "more",
+ "away",
+ "still",
+ "them",
+ "take",
+ "thing",
+ "even",
+ "through",
+ "long",
+ "always",
+ "world",
+ "too",
+ "friend",
+ "tell",
+ "try",
+ "hand",
+ "thought",
+ "over",
+ "here",
+ "other",
+ "need",
+ "smile",
+ "again",
+ "much",
+ "cry",
+ "been",
+ "night",
+ "ever",
+ "little",
+ "said",
+ "end",
+ "some",
+ "those",
+ "around",
+ "mind",
+ "people",
+ "girl",
+ "leave",
+ "dream",
+ "left",
+ "turn",
+ "myself",
+ "give",
+ "nothing",
+ "really",
+ "off",
+ "before",
+ "something",
+ "find",
+ "walk",
+ "wish",
+ "good",
+ "once",
+ "place",
+ "ask",
+ "stop",
+ "keep",
+ "watch",
+ "seem",
+ "everything",
+ "wait",
+ "got",
+ "yet",
+ "made",
+ "remember",
+ "start",
+ "alone",
+ "run",
+ "hope",
+ "maybe",
+ "believe",
+ "body",
+ "hate",
+ "after",
+ "close",
+ "talk",
+ "stand",
+ "own",
+ "each",
+ "hurt",
+ "help",
+ "home",
+ "god",
+ "soul",
+ "new",
+ "many",
+ "two",
+ "inside",
+ "should",
+ "true",
+ "first",
+ "fear",
+ "mean",
+ "better",
+ "play",
+ "another",
+ "gone",
+ "change",
+ "use",
+ "wonder",
+ "someone",
+ "hair",
+ "cold",
+ "open",
+ "best",
+ "any",
+ "behind",
+ "happen",
+ "water",
+ "dark",
+ "laugh",
+ "stay",
+ "forever",
+ "name",
+ "work",
+ "show",
+ "sky",
+ "break",
+ "came",
+ "deep",
+ "door",
+ "put",
+ "black",
+ "together",
+ "upon",
+ "happy",
+ "such",
+ "great",
+ "white",
+ "matter",
+ "fill",
+ "past",
+ "please",
+ "burn",
+ "cause",
+ "enough",
+ "touch",
+ "moment",
+ "soon",
+ "voice",
+ "scream",
+ "anything",
+ "stare",
+ "sound",
+ "red",
+ "everyone",
+ "hide",
+ "kiss",
+ "truth",
+ "death",
+ "beautiful",
+ "mine",
+ "blood",
+ "broken",
+ "very",
+ "pass",
+ "next",
+ "forget",
+ "tree",
+ "wrong",
+ "air",
+ "mother",
+ "understand",
+ "lip",
+ "hit",
+ "wall",
+ "memory",
+ "sleep",
+ "free",
+ "high",
+ "realize",
+ "school",
+ "might",
+ "skin",
+ "sweet",
+ "perfect",
+ "blue",
+ "kill",
+ "breath",
+ "dance",
+ "against",
+ "fly",
+ "between",
+ "grow",
+ "strong",
+ "under",
+ "listen",
+ "bring",
+ "sometimes",
+ "speak",
+ "pull",
+ "person",
+ "become",
+ "family",
+ "begin",
+ "ground",
+ "real",
+ "small",
+ "father",
+ "sure",
+ "feet",
+ "rest",
+ "young",
+ "finally",
+ "land",
+ "across",
+ "today",
+ "different",
+ "guy",
+ "line",
+ "fire",
+ "reason",
+ "reach",
+ "second",
+ "slowly",
+ "write",
+ "eat",
+ "smell",
+ "mouth",
+ "step",
+ "learn",
+ "three",
+ "floor",
+ "promise",
+ "breathe",
+ "darkness",
+ "push",
+ "earth",
+ "guess",
+ "save",
+ "song",
+ "above",
+ "along",
+ "both",
+ "color",
+ "house",
+ "almost",
+ "sorry",
+ "anymore",
+ "brother",
+ "okay",
+ "dear",
+ "game",
+ "fade",
+ "already",
+ "apart",
+ "warm",
+ "beauty",
+ "heard",
+ "notice",
+ "question",
+ "shine",
+ "began",
+ "piece",
+ "whole",
+ "shadow",
+ "secret",
+ "street",
+ "within",
+ "finger",
+ "point",
+ "morning",
+ "whisper",
+ "child",
+ "moon",
+ "green",
+ "story",
+ "glass",
+ "kid",
+ "silence",
+ "since",
+ "soft",
+ "yourself",
+ "empty",
+ "shall",
+ "angel",
+ "answer",
+ "baby",
+ "bright",
+ "dad",
+ "path",
+ "worry",
+ "hour",
+ "drop",
+ "follow",
+ "power",
+ "war",
+ "half",
+ "flow",
+ "heaven",
+ "act",
+ "chance",
+ "fact",
+ "least",
+ "tired",
+ "children",
+ "near",
+ "quite",
+ "afraid",
+ "rise",
+ "sea",
+ "taste",
+ "window",
+ "cover",
+ "nice",
+ "trust",
+ "lot",
+ "sad",
+ "cool",
+ "force",
+ "peace",
+ "return",
+ "blind",
+ "easy",
+ "ready",
+ "roll",
+ "rose",
+ "drive",
+ "held",
+ "music",
+ "beneath",
+ "hang",
+ "mom",
+ "paint",
+ "emotion",
+ "quiet",
+ "clear",
+ "cloud",
+ "few",
+ "pretty",
+ "bird",
+ "outside",
+ "paper",
+ "picture",
+ "front",
+ "rock",
+ "simple",
+ "anyone",
+ "meant",
+ "reality",
+ "road",
+ "sense",
+ "waste",
+ "bit",
+ "leaf",
+ "thank",
+ "happiness",
+ "meet",
+ "men",
+ "smoke",
+ "truly",
+ "decide",
+ "self",
+ "age",
+ "book",
+ "form",
+ "alive",
+ "carry",
+ "escape",
+ "damn",
+ "instead",
+ "able",
+ "ice",
+ "minute",
+ "throw",
+ "catch",
+ "leg",
+ "ring",
+ "course",
+ "goodbye",
+ "lead",
+ "poem",
+ "sick",
+ "corner",
+ "desire",
+ "known",
+ "problem",
+ "remind",
+ "shoulder",
+ "suppose",
+ "toward",
+ "wave",
+ "drink",
+ "jump",
+ "woman",
+ "pretend",
+ "sister",
+ "week",
+ "human",
+ "joy",
+ "crack",
+ "grey",
+ "pray",
+ "surprise",
+ "dry",
+ "knee",
+ "less",
+ "search",
+ "bleed",
+ "caught",
+ "clean",
+ "embrace",
+ "future",
+ "king",
+ "son",
+ "sorrow",
+ "chest",
+ "hug",
+ "remain",
+ "sat",
+ "worth",
+ "blow",
+ "daddy",
+ "final",
+ "parent",
+ "tight",
+ "also",
+ "create",
+ "lonely",
+ "safe",
+ "cross",
+ "dress",
+ "evil",
+ "silent",
+ "bone",
+ "fate",
+ "perhaps",
+ "anger",
+ "class",
+ "scar",
+ "snow",
+ "tiny",
+ "tonight",
+ "continue",
+ "control",
+ "dog",
+ "edge",
+ "mirror",
+ "month",
+ "suddenly",
+ "comfort",
+ "given",
+ "loud",
+ "quickly",
+ "gaze",
+ "plan",
+ "rush",
+ "stone",
+ "town",
+ "battle",
+ "ignore",
+ "spirit",
+ "stood",
+ "stupid",
+ "yours",
+ "brown",
+ "build",
+ "dust",
+ "hey",
+ "kept",
+ "pay",
+ "phone",
+ "twist",
+ "although",
+ "ball",
+ "beyond",
+ "hidden",
+ "nose",
+ "taken",
+ "fail",
+ "float",
+ "pure",
+ "somehow",
+ "wash",
+ "wrap",
+ "angry",
+ "cheek",
+ "creature",
+ "forgotten",
+ "heat",
+ "rip",
+ "single",
+ "space",
+ "special",
+ "weak",
+ "whatever",
+ "yell",
+ "anyway",
+ "blame",
+ "job",
+ "choose",
+ "country",
+ "curse",
+ "drift",
+ "echo",
+ "figure",
+ "grew",
+ "laughter",
+ "neck",
+ "suffer",
+ "worse",
+ "yeah",
+ "disappear",
+ "foot",
+ "forward",
+ "knife",
+ "mess",
+ "somewhere",
+ "stomach",
+ "storm",
+ "beg",
+ "idea",
+ "lift",
+ "offer",
+ "breeze",
+ "field",
+ "five",
+ "often",
+ "simply",
+ "stuck",
+ "win",
+ "allow",
+ "confuse",
+ "enjoy",
+ "except",
+ "flower",
+ "seek",
+ "strength",
+ "calm",
+ "grin",
+ "gun",
+ "heavy",
+ "hill",
+ "large",
+ "ocean",
+ "shoe",
+ "sigh",
+ "straight",
+ "summer",
+ "tongue",
+ "accept",
+ "crazy",
+ "everyday",
+ "exist",
+ "grass",
+ "mistake",
+ "sent",
+ "shut",
+ "surround",
+ "table",
+ "ache",
+ "brain",
+ "destroy",
+ "heal",
+ "nature",
+ "shout",
+ "sign",
+ "stain",
+ "choice",
+ "doubt",
+ "glance",
+ "glow",
+ "mountain",
+ "queen",
+ "stranger",
+ "throat",
+ "tomorrow",
+ "city",
+ "either",
+ "fish",
+ "flame",
+ "rather",
+ "shape",
+ "spin",
+ "spread",
+ "ash",
+ "distance",
+ "finish",
+ "image",
+ "imagine",
+ "important",
+ "nobody",
+ "shatter",
+ "warmth",
+ "became",
+ "feed",
+ "flesh",
+ "funny",
+ "lust",
+ "shirt",
+ "trouble",
+ "yellow",
+ "attention",
+ "bare",
+ "bite",
+ "money",
+ "protect",
+ "amaze",
+ "appear",
+ "born",
+ "choke",
+ "completely",
+ "daughter",
+ "fresh",
+ "friendship",
+ "gentle",
+ "probably",
+ "six",
+ "deserve",
+ "expect",
+ "grab",
+ "middle",
+ "nightmare",
+ "river",
+ "thousand",
+ "weight",
+ "worst",
+ "wound",
+ "barely",
+ "bottle",
+ "cream",
+ "regret",
+ "relationship",
+ "stick",
+ "test",
+ "crush",
+ "endless",
+ "fault",
+ "itself",
+ "rule",
+ "spill",
+ "art",
+ "circle",
+ "join",
+ "kick",
+ "mask",
+ "master",
+ "passion",
+ "quick",
+ "raise",
+ "smooth",
+ "unless",
+ "wander",
+ "actually",
+ "broke",
+ "chair",
+ "deal",
+ "favorite",
+ "gift",
+ "note",
+ "number",
+ "sweat",
+ "box",
+ "chill",
+ "clothes",
+ "lady",
+ "mark",
+ "park",
+ "poor",
+ "sadness",
+ "tie",
+ "animal",
+ "belong",
+ "brush",
+ "consume",
+ "dawn",
+ "forest",
+ "innocent",
+ "pen",
+ "pride",
+ "stream",
+ "thick",
+ "clay",
+ "complete",
+ "count",
+ "draw",
+ "faith",
+ "press",
+ "silver",
+ "struggle",
+ "surface",
+ "taught",
+ "teach",
+ "wet",
+ "bless",
+ "chase",
+ "climb",
+ "enter",
+ "letter",
+ "melt",
+ "metal",
+ "movie",
+ "stretch",
+ "swing",
+ "vision",
+ "wife",
+ "beside",
+ "crash",
+ "forgot",
+ "guide",
+ "haunt",
+ "joke",
+ "knock",
+ "plant",
+ "pour",
+ "prove",
+ "reveal",
+ "steal",
+ "stuff",
+ "trip",
+ "wood",
+ "wrist",
+ "bother",
+ "bottom",
+ "crawl",
+ "crowd",
+ "fix",
+ "forgive",
+ "frown",
+ "grace",
+ "loose",
+ "lucky",
+ "party",
+ "release",
+ "surely",
+ "survive",
+ "teacher",
+ "gently",
+ "grip",
+ "speed",
+ "suicide",
+ "travel",
+ "treat",
+ "vein",
+ "written",
+ "cage",
+ "chain",
+ "conversation",
+ "date",
+ "enemy",
+ "however",
+ "interest",
+ "million",
+ "page",
+ "pink",
+ "proud",
+ "sway",
+ "themselves",
+ "winter",
+ "church",
+ "cruel",
+ "cup",
+ "demon",
+ "experience",
+ "freedom",
+ "pair",
+ "pop",
+ "purpose",
+ "respect",
+ "shoot",
+ "softly",
+ "state",
+ "strange",
+ "bar",
+ "birth",
+ "curl",
+ "dirt",
+ "excuse",
+ "lord",
+ "lovely",
+ "monster",
+ "order",
+ "pack",
+ "pants",
+ "pool",
+ "scene",
+ "seven",
+ "shame",
+ "slide",
+ "ugly",
+ "among",
+ "blade",
+ "blonde",
+ "closet",
+ "creek",
+ "deny",
+ "drug",
+ "eternity",
+ "gain",
+ "grade",
+ "handle",
+ "key",
+ "linger",
+ "pale",
+ "prepare",
+ "swallow",
+ "swim",
+ "tremble",
+ "wheel",
+ "won",
+ "cast",
+ "cigarette",
+ "claim",
+ "college",
+ "direction",
+ "dirty",
+ "gather",
+ "ghost",
+ "hundred",
+ "loss",
+ "lung",
+ "orange",
+ "present",
+ "swear",
+ "swirl",
+ "twice",
+ "wild",
+ "bitter",
+ "blanket",
+ "doctor",
+ "everywhere",
+ "flash",
+ "grown",
+ "knowledge",
+ "numb",
+ "pressure",
+ "radio",
+ "repeat",
+ "ruin",
+ "spend",
+ "unknown",
+ "buy",
+ "clock",
+ "devil",
+ "early",
+ "false",
+ "fantasy",
+ "pound",
+ "precious",
+ "refuse",
+ "sheet",
+ "teeth",
+ "welcome",
+ "add",
+ "ahead",
+ "block",
+ "bury",
+ "caress",
+ "content",
+ "depth",
+ "despite",
+ "distant",
+ "marry",
+ "purple",
+ "threw",
+ "whenever",
+ "bomb",
+ "dull",
+ "easily",
+ "grasp",
+ "hospital",
+ "innocence",
+ "normal",
+ "receive",
+ "reply",
+ "rhyme",
+ "shade",
+ "someday",
+ "sword",
+ "toe",
+ "visit",
+ "asleep",
+ "bought",
+ "center",
+ "consider",
+ "flat",
+ "hero",
+ "history",
+ "ink",
+ "insane",
+ "muscle",
+ "mystery",
+ "pocket",
+ "reflection",
+ "shove",
+ "silently",
+ "smart",
+ "soldier",
+ "spot",
+ "stress",
+ "train",
+ "type",
+ "view",
+ "whether",
+ "bus",
+ "energy",
+ "explain",
+ "holy",
+ "hunger",
+ "inch",
+ "magic",
+ "mix",
+ "noise",
+ "nowhere",
+ "prayer",
+ "presence",
+ "shock",
+ "snap",
+ "spider",
+ "study",
+ "thunder",
+ "trail",
+ "admit",
+ "agree",
+ "bag",
+ "bang",
+ "bound",
+ "butterfly",
+ "cute",
+ "exactly",
+ "explode",
+ "familiar",
+ "fold",
+ "further",
+ "pierce",
+ "reflect",
+ "scent",
+ "selfish",
+ "sharp",
+ "sink",
+ "spring",
+ "stumble",
+ "universe",
+ "weep",
+ "women",
+ "wonderful",
+ "action",
+ "ancient",
+ "attempt",
+ "avoid",
+ "birthday",
+ "branch",
+ "chocolate",
+ "core",
+ "depress",
+ "drunk",
+ "especially",
+ "focus",
+ "fruit",
+ "honest",
+ "match",
+ "palm",
+ "perfectly",
+ "pillow",
+ "pity",
+ "poison",
+ "roar",
+ "shift",
+ "slightly",
+ "thump",
+ "truck",
+ "tune",
+ "twenty",
+ "unable",
+ "wipe",
+ "wrote",
+ "coat",
+ "constant",
+ "dinner",
+ "drove",
+ "egg",
+ "eternal",
+ "flight",
+ "flood",
+ "frame",
+ "freak",
+ "gasp",
+ "glad",
+ "hollow",
+ "motion",
+ "peer",
+ "plastic",
+ "root",
+ "screen",
+ "season",
+ "sting",
+ "strike",
+ "team",
+ "unlike",
+ "victim",
+ "volume",
+ "warn",
+ "weird",
+ "attack",
+ "await",
+ "awake",
+ "built",
+ "charm",
+ "crave",
+ "despair",
+ "fought",
+ "grant",
+ "grief",
+ "horse",
+ "limit",
+ "message",
+ "ripple",
+ "sanity",
+ "scatter",
+ "serve",
+ "split",
+ "string",
+ "trick",
+ "annoy",
+ "blur",
+ "boat",
+ "brave",
+ "clearly",
+ "cling",
+ "connect",
+ "fist",
+ "forth",
+ "imagination",
+ "iron",
+ "jock",
+ "judge",
+ "lesson",
+ "milk",
+ "misery",
+ "nail",
+ "naked",
+ "ourselves",
+ "poet",
+ "possible",
+ "princess",
+ "sail",
+ "size",
+ "snake",
+ "society",
+ "stroke",
+ "torture",
+ "toss",
+ "trace",
+ "wise",
+ "bloom",
+ "bullet",
+ "cell",
+ "check",
+ "cost",
+ "darling",
+ "during",
+ "footstep",
+ "fragile",
+ "hallway",
+ "hardly",
+ "horizon",
+ "invisible",
+ "journey",
+ "midnight",
+ "mud",
+ "nod",
+ "pause",
+ "relax",
+ "shiver",
+ "sudden",
+ "value",
+ "youth",
+ "abuse",
+ "admire",
+ "blink",
+ "breast",
+ "bruise",
+ "constantly",
+ "couple",
+ "creep",
+ "curve",
+ "difference",
+ "dumb",
+ "emptiness",
+ "gotta",
+ "honor",
+ "plain",
+ "planet",
+ "recall",
+ "rub",
+ "ship",
+ "slam",
+ "soar",
+ "somebody",
+ "tightly",
+ "weather",
+ "adore",
+ "approach",
+ "bond",
+ "bread",
+ "burst",
+ "candle",
+ "coffee",
+ "cousin",
+ "crime",
+ "desert",
+ "flutter",
+ "frozen",
+ "grand",
+ "heel",
+ "hello",
+ "language",
+ "level",
+ "movement",
+ "pleasure",
+ "powerful",
+ "random",
+ "rhythm",
+ "settle",
+ "silly",
+ "slap",
+ "sort",
+ "spoken",
+ "steel",
+ "threaten",
+ "tumble",
+ "upset",
+ "aside",
+ "awkward",
+ "bee",
+ "blank",
+ "board",
+ "button",
+ "card",
+ "carefully",
+ "complain",
+ "crap",
+ "deeply",
+ "discover",
+ "drag",
+ "dread",
+ "effort",
+ "entire",
+ "fairy",
+ "giant",
+ "gotten",
+ "greet",
+ "illusion",
+ "jeans",
+ "leap",
+ "liquid",
+ "march",
+ "mend",
+ "nervous",
+ "nine",
+ "replace",
+ "rope",
+ "spine",
+ "stole",
+ "terror",
+ "accident",
+ "apple",
+ "balance",
+ "boom",
+ "childhood",
+ "collect",
+ "demand",
+ "depression",
+ "eventually",
+ "faint",
+ "glare",
+ "goal",
+ "group",
+ "honey",
+ "kitchen",
+ "laid",
+ "limb",
+ "machine",
+ "mere",
+ "mold",
+ "murder",
+ "nerve",
+ "painful",
+ "poetry",
+ "prince",
+ "rabbit",
+ "shelter",
+ "shore",
+ "shower",
+ "soothe",
+ "stair",
+ "steady",
+ "sunlight",
+ "tangle",
+ "tease",
+ "treasure",
+ "uncle",
+ "begun",
+ "bliss",
+ "canvas",
+ "cheer",
+ "claw",
+ "clutch",
+ "commit",
+ "crimson",
+ "crystal",
+ "delight",
+ "doll",
+ "existence",
+ "express",
+ "fog",
+ "football",
+ "gay",
+ "goose",
+ "guard",
+ "hatred",
+ "illuminate",
+ "mass",
+ "math",
+ "mourn",
+ "rich",
+ "rough",
+ "skip",
+ "stir",
+ "student",
+ "style",
+ "support",
+ "thorn",
+ "tough",
+ "yard",
+ "yearn",
+ "yesterday",
+ "advice",
+ "appreciate",
+ "autumn",
+ "bank",
+ "beam",
+ "bowl",
+ "capture",
+ "carve",
+ "collapse",
+ "confusion",
+ "creation",
+ "dove",
+ "feather",
+ "girlfriend",
+ "glory",
+ "government",
+ "harsh",
+ "hop",
+ "inner",
+ "loser",
+ "moonlight",
+ "neighbor",
+ "neither",
+ "peach",
+ "pig",
+ "praise",
+ "screw",
+ "shield",
+ "shimmer",
+ "sneak",
+ "stab",
+ "subject",
+ "throughout",
+ "thrown",
+ "tower",
+ "twirl",
+ "wow",
+ "army",
+ "arrive",
+ "bathroom",
+ "bump",
+ "cease",
+ "cookie",
+ "couch",
+ "courage",
+ "dim",
+ "guilt",
+ "howl",
+ "hum",
+ "husband",
+ "insult",
+ "led",
+ "lunch",
+ "mock",
+ "mostly",
+ "natural",
+ "nearly",
+ "needle",
+ "nerd",
+ "peaceful",
+ "perfection",
+ "pile",
+ "price",
+ "remove",
+ "roam",
+ "sanctuary",
+ "serious",
+ "shiny",
+ "shook",
+ "sob",
+ "stolen",
+ "tap",
+ "vain",
+ "void",
+ "warrior",
+ "wrinkle",
+ "affection",
+ "apologize",
+ "blossom",
+ "bounce",
+ "bridge",
+ "cheap",
+ "crumble",
+ "decision",
+ "descend",
+ "desperately",
+ "dig",
+ "dot",
+ "flip",
+ "frighten",
+ "heartbeat",
+ "huge",
+ "lazy",
+ "lick",
+ "odd",
+ "opinion",
+ "process",
+ "puzzle",
+ "quietly",
+ "retreat",
+ "score",
+ "sentence",
+ "separate",
+ "situation",
+ "skill",
+ "soak",
+ "square",
+ "stray",
+ "taint",
+ "task",
+ "tide",
+ "underneath",
+ "veil",
+ "whistle",
+ "anywhere",
+ "bedroom",
+ "bid",
+ "bloody",
+ "burden",
+ "careful",
+ "compare",
+ "concern",
+ "curtain",
+ "decay",
+ "defeat",
+ "describe",
+ "double",
+ "dreamer",
+ "driver",
+ "dwell",
+ "evening",
+ "flare",
+ "flicker",
+ "grandma",
+ "guitar",
+ "harm",
+ "horrible",
+ "hungry",
+ "indeed",
+ "lace",
+ "melody",
+ "monkey",
+ "nation",
+ "object",
+ "obviously",
+ "rainbow",
+ "salt",
+ "scratch",
+ "shown",
+ "shy",
+ "stage",
+ "stun",
+ "third",
+ "tickle",
+ "useless",
+ "weakness",
+ "worship",
+ "worthless",
+ "afternoon",
+ "beard",
+ "boyfriend",
+ "bubble",
+ "busy",
+ "certain",
+ "chin",
+ "concrete",
+ "desk",
+ "diamond",
+ "doom",
+ "drawn",
+ "due",
+ "felicity",
+ "freeze",
+ "frost",
+ "garden",
+ "glide",
+ "harmony",
+ "hopefully",
+ "hunt",
+ "jealous",
+ "lightning",
+ "mama",
+ "mercy",
+ "peel",
+ "physical",
+ "position",
+ "pulse",
+ "punch",
+ "quit",
+ "rant",
+ "respond",
+ "salty",
+ "sane",
+ "satisfy",
+ "savior",
+ "sheep",
+ "slept",
+ "social",
+ "sport",
+ "tuck",
+ "utter",
+ "valley",
+ "wolf",
+ "aim",
+ "alas",
+ "alter",
+ "arrow",
+ "awaken",
+ "beaten",
+ "belief",
+ "brand",
+ "ceiling",
+ "cheese",
+ "clue",
+ "confidence",
+ "connection",
+ "daily",
+ "disguise",
+ "eager",
+ "erase",
+ "essence",
+ "everytime",
+ "expression",
+ "fan",
+ "flag",
+ "flirt",
+ "foul",
+ "fur",
+ "giggle",
+ "glorious",
+ "ignorance",
+ "law",
+ "lifeless",
+ "measure",
+ "mighty",
+ "muse",
+ "north",
+ "opposite",
+ "paradise",
+ "patience",
+ "patient",
+ "pencil",
+ "petal",
+ "plate",
+ "ponder",
+ "possibly",
+ "practice",
+ "slice",
+ "spell",
+ "stock",
+ "strife",
+ "strip",
+ "suffocate",
+ "suit",
+ "tender",
+ "tool",
+ "trade",
+ "velvet",
+ "verse",
+ "waist",
+ "witch",
+ "aunt",
+ "bench",
+ "bold",
+ "cap",
+ "certainly",
+ "click",
+ "companion",
+ "creator",
+ "dart",
+ "delicate",
+ "determine",
+ "dish",
+ "dragon",
+ "drama",
+ "drum",
+ "dude",
+ "everybody",
+ "feast",
+ "forehead",
+ "former",
+ "fright",
+ "fully",
+ "gas",
+ "hook",
+ "hurl",
+ "invite",
+ "juice",
+ "manage",
+ "moral",
+ "possess",
+ "raw",
+ "rebel",
+ "royal",
+ "scale",
+ "scary",
+ "several",
+ "slight",
+ "stubborn",
+ "swell",
+ "talent",
+ "tea",
+ "terrible",
+ "thread",
+ "torment",
+ "trickle",
+ "usually",
+ "vast",
+ "violence",
+ "weave",
+ "acid",
+ "agony",
+ "ashamed",
+ "awe",
+ "belly",
+ "blend",
+ "blush",
+ "character",
+ "cheat",
+ "common",
+ "company",
+ "coward",
+ "creak",
+ "danger",
+ "deadly",
+ "defense",
+ "define",
+ "depend",
+ "desperate",
+ "destination",
+ "dew",
+ "duck",
+ "dusty",
+ "embarrass",
+ "engine",
+ "example",
+ "explore",
+ "foe",
+ "freely",
+ "frustrate",
+ "generation",
+ "glove",
+ "guilty",
+ "health",
+ "hurry",
+ "idiot",
+ "impossible",
+ "inhale",
+ "jaw",
+ "kingdom",
+ "mention",
+ "mist",
+ "moan",
+ "mumble",
+ "mutter",
+ "observe",
+ "ode",
+ "pathetic",
+ "pattern",
+ "pie",
+ "prefer",
+ "puff",
+ "rape",
+ "rare",
+ "revenge",
+ "rude",
+ "scrape",
+ "spiral",
+ "squeeze",
+ "strain",
+ "sunset",
+ "suspend",
+ "sympathy",
+ "thigh",
+ "throne",
+ "total",
+ "unseen",
+ "weapon",
+ "weary",
+}
diff --git a/ethdb/.gitignore b/ethdb/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..f725d58d14f7d1b6a8c41c45f78b4f38f529ae9e
--- /dev/null
+++ b/ethdb/.gitignore
@@ -0,0 +1,12 @@
+# See http://help.github.com/ignore-files/ for more about ignoring files.
+#
+# If you find yourself ignoring temporary files generated by your text editor
+# or operating system, you probably want to add a global ignore instead:
+# git config --global core.excludesfile ~/.gitignore_global
+
+/tmp
+*/**/*un~
+*un~
+.DS_Store
+*/**/.DS_Store
+
diff --git a/ethdb/README.md b/ethdb/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..5bed8eedc6c64288d96b29c86006cdb23295ac01
--- /dev/null
+++ b/ethdb/README.md
@@ -0,0 +1,11 @@
+# ethdb
+
+The ethdb package contains the ethereum database interfaces
+
+# Installation
+
+`go get github.com/ethereum/ethdb-go`
+
+# Usage
+
+Todo :-)
diff --git a/ethdb/database.go b/ethdb/database.go
new file mode 100644
index 0000000000000000000000000000000000000000..de3afd74b0fea944b8b8fd19652a92bcca308543
--- /dev/null
+++ b/ethdb/database.go
@@ -0,0 +1,73 @@
+package ethdb
+
+import (
+ "fmt"
+ "path"
+
+ "github.com/ethereum/go-ethereum/ethutil"
+ "github.com/syndtr/goleveldb/leveldb"
+)
+
+type LDBDatabase struct {
+ db *leveldb.DB
+}
+
+func NewLDBDatabase(name string) (*LDBDatabase, error) {
+ dbPath := path.Join(ethutil.Config.ExecPath, name)
+
+ // Open the db
+ db, err := leveldb.OpenFile(dbPath, nil)
+ if err != nil {
+ return nil, err
+ }
+
+ database := &LDBDatabase{db: db}
+
+ return database, nil
+}
+
+func (db *LDBDatabase) Put(key []byte, value []byte) {
+ err := db.db.Put(key, value, nil)
+ if err != nil {
+ fmt.Println("Error put", err)
+ }
+}
+
+func (db *LDBDatabase) Get(key []byte) ([]byte, error) {
+ return db.db.Get(key, nil)
+}
+
+func (db *LDBDatabase) Delete(key []byte) error {
+ return db.db.Delete(key, nil)
+}
+
+func (db *LDBDatabase) Db() *leveldb.DB {
+ return db.db
+}
+
+func (db *LDBDatabase) LastKnownTD() []byte {
+ data, _ := db.db.Get([]byte("LTD"), nil)
+
+ if len(data) == 0 {
+ data = []byte{0x0}
+ }
+
+ return data
+}
+
+func (db *LDBDatabase) Close() {
+ // Close the leveldb database
+ db.db.Close()
+}
+
+func (db *LDBDatabase) Print() {
+ iter := db.db.NewIterator(nil, nil)
+ for iter.Next() {
+ key := iter.Key()
+ value := iter.Value()
+
+ fmt.Printf("%x(%d): ", key, len(key))
+ node := ethutil.NewValueFromBytes(value)
+ fmt.Printf("%v\n", node)
+ }
+}
diff --git a/ethdb/database_test.go b/ethdb/database_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..bb1b4de2a0f757d98e98f830932b7e735d13e0a3
--- /dev/null
+++ b/ethdb/database_test.go
@@ -0,0 +1,6 @@
+package ethdb
+
+import (
+ _ "fmt"
+ _ "testing"
+)
diff --git a/ethdb/memory_database.go b/ethdb/memory_database.go
new file mode 100644
index 0000000000000000000000000000000000000000..459373eeaeaed0c6993a287427c17ee6f8c80fc6
--- /dev/null
+++ b/ethdb/memory_database.go
@@ -0,0 +1,63 @@
+package ethdb
+
+import (
+ "fmt"
+
+ "github.com/ethereum/go-ethereum/ethutil"
+)
+
+/*
+ * This is a test memory database. Do not use for any production it does not get persisted
+ */
+type MemDatabase struct {
+ db map[string][]byte
+}
+
+func NewMemDatabase() (*MemDatabase, error) {
+ db := &MemDatabase{db: make(map[string][]byte)}
+
+ return db, nil
+}
+
+func (db *MemDatabase) Put(key []byte, value []byte) {
+ db.db[string(key)] = value
+}
+
+func (db *MemDatabase) Get(key []byte) ([]byte, error) {
+ return db.db[string(key)], nil
+}
+
+/*
+func (db *MemDatabase) GetKeys() []*ethutil.Key {
+ data, _ := db.Get([]byte("KeyRing"))
+
+ return []*ethutil.Key{ethutil.NewKeyFromBytes(data)}
+}
+*/
+
+func (db *MemDatabase) Delete(key []byte) error {
+ delete(db.db, string(key))
+
+ return nil
+}
+
+func (db *MemDatabase) Print() {
+ for key, val := range db.db {
+ fmt.Printf("%x(%d): ", key, len(key))
+ node := ethutil.NewValueFromBytes(val)
+ fmt.Printf("%q\n", node.Interface())
+ }
+}
+
+func (db *MemDatabase) Close() {
+}
+
+func (db *MemDatabase) LastKnownTD() []byte {
+ data, _ := db.Get([]byte("LastKnownTotalDifficulty"))
+
+ if len(data) == 0 || data == nil {
+ data = []byte{0x0}
+ }
+
+ return data
+}
diff --git a/ethereum.go b/ethereum.go
new file mode 100644
index 0000000000000000000000000000000000000000..c2d2095977313b7259b76a2ead758a9863ac3fe5
--- /dev/null
+++ b/ethereum.go
@@ -0,0 +1,658 @@
+package eth
+
+import (
+ "container/list"
+ "encoding/json"
+ "fmt"
+ "math/big"
+ "math/rand"
+ "net"
+ "path"
+ "strconv"
+ "strings"
+ "sync"
+ "sync/atomic"
+ "time"
+
+ "github.com/ethereum/go-ethereum/ethchain"
+ "github.com/ethereum/go-ethereum/ethcrypto"
+ "github.com/ethereum/go-ethereum/ethlog"
+ "github.com/ethereum/go-ethereum/ethstate"
+ "github.com/ethereum/go-ethereum/ethutil"
+ "github.com/ethereum/go-ethereum/ethwire"
+ "github.com/ethereum/go-ethereum/event"
+ "github.com/ethereum/go-ethereum/rpc"
+)
+
+const (
+ seedTextFileUri string = "http://www.ethereum.org/servers.poc3.txt"
+ seedNodeAddress = "poc-7.ethdev.com:30303"
+)
+
+var ethlogger = ethlog.NewLogger("SERV")
+
+func eachPeer(peers *list.List, callback func(*Peer, *list.Element)) {
+ // Loop thru the peers and close them (if we had them)
+ for e := peers.Front(); e != nil; e = e.Next() {
+ callback(e.Value.(*Peer), e)
+ }
+}
+
+const (
+ processReapingTimeout = 60 // TODO increase
+)
+
+type Ethereum struct {
+ // Channel for shutting down the ethereum
+ shutdownChan chan bool
+ quit chan bool
+
+ // DB interface
+ db ethutil.Database
+ // State manager for processing new blocks and managing the over all states
+ stateManager *ethchain.StateManager
+ // The transaction pool. Transaction can be pushed on this pool
+ // for later including in the blocks
+ txPool *ethchain.TxPool
+ // The canonical chain
+ blockChain *ethchain.ChainManager
+ // The block pool
+ blockPool *BlockPool
+ // Eventer
+ eventMux event.TypeMux
+ // Peers
+ peers *list.List
+ // Nonce
+ Nonce uint64
+
+ Addr net.Addr
+ Port string
+
+ blacklist [][]byte
+
+ peerMut sync.Mutex
+
+ // Capabilities for outgoing peers
+ serverCaps Caps
+
+ nat NAT
+
+ // Specifies the desired amount of maximum peers
+ MaxPeers int
+
+ Mining bool
+
+ listening bool
+
+ RpcServer *rpc.JsonRpcServer
+
+ keyManager *ethcrypto.KeyManager
+
+ clientIdentity ethwire.ClientIdentity
+
+ isUpToDate bool
+
+ filterMu sync.RWMutex
+ filterId int
+ filters map[int]*ethchain.Filter
+}
+
+func New(db ethutil.Database, clientIdentity ethwire.ClientIdentity, keyManager *ethcrypto.KeyManager, caps Caps, usePnp bool) (*Ethereum, error) {
+ var err error
+ var nat NAT
+
+ if usePnp {
+ nat, err = Discover()
+ if err != nil {
+ ethlogger.Debugln("UPnP failed", err)
+ }
+ }
+
+ bootstrapDb(db)
+
+ ethutil.Config.Db = db
+
+ nonce, _ := ethutil.RandomUint64()
+ ethereum := &Ethereum{
+ shutdownChan: make(chan bool),
+ quit: make(chan bool),
+ db: db,
+ peers: list.New(),
+ Nonce: nonce,
+ serverCaps: caps,
+ nat: nat,
+ keyManager: keyManager,
+ clientIdentity: clientIdentity,
+ isUpToDate: true,
+ filters: make(map[int]*ethchain.Filter),
+ }
+
+ ethereum.blockPool = NewBlockPool(ethereum)
+ ethereum.txPool = ethchain.NewTxPool(ethereum)
+ ethereum.blockChain = ethchain.NewChainManager(ethereum)
+ ethereum.stateManager = ethchain.NewStateManager(ethereum)
+
+ // Start the tx pool
+ ethereum.txPool.Start()
+
+ return ethereum, nil
+}
+
+func (s *Ethereum) KeyManager() *ethcrypto.KeyManager {
+ return s.keyManager
+}
+
+func (s *Ethereum) ClientIdentity() ethwire.ClientIdentity {
+ return s.clientIdentity
+}
+
+func (s *Ethereum) ChainManager() *ethchain.ChainManager {
+ return s.blockChain
+}
+
+func (s *Ethereum) StateManager() *ethchain.StateManager {
+ return s.stateManager
+}
+
+func (s *Ethereum) TxPool() *ethchain.TxPool {
+ return s.txPool
+}
+func (s *Ethereum) BlockPool() *BlockPool {
+ return s.blockPool
+}
+func (s *Ethereum) EventMux() *event.TypeMux {
+ return &s.eventMux
+}
+func (self *Ethereum) Db() ethutil.Database {
+ return self.db
+}
+
+func (s *Ethereum) ServerCaps() Caps {
+ return s.serverCaps
+}
+func (s *Ethereum) IsMining() bool {
+ return s.Mining
+}
+func (s *Ethereum) PeerCount() int {
+ return s.peers.Len()
+}
+func (s *Ethereum) IsUpToDate() bool {
+ upToDate := true
+ eachPeer(s.peers, func(peer *Peer, e *list.Element) {
+ if atomic.LoadInt32(&peer.connected) == 1 {
+ if peer.catchingUp == true && peer.versionKnown {
+ upToDate = false
+ }
+ }
+ })
+ return upToDate
+}
+func (s *Ethereum) PushPeer(peer *Peer) {
+ s.peers.PushBack(peer)
+}
+func (s *Ethereum) IsListening() bool {
+ return s.listening
+}
+
+func (s *Ethereum) HighestTDPeer() (td *big.Int) {
+ td = big.NewInt(0)
+
+ eachPeer(s.peers, func(p *Peer, v *list.Element) {
+ if p.td.Cmp(td) > 0 {
+ td = p.td
+ }
+ })
+
+ return
+}
+
+func (self *Ethereum) BlacklistPeer(peer *Peer) {
+ self.blacklist = append(self.blacklist, peer.pubkey)
+}
+
+func (s *Ethereum) AddPeer(conn net.Conn) {
+ peer := NewPeer(conn, s, true)
+
+ if peer != nil {
+ if s.peers.Len() < s.MaxPeers {
+ peer.Start()
+ } else {
+ ethlogger.Debugf("Max connected peers reached. Not adding incoming peer.")
+ }
+ }
+}
+
+func (s *Ethereum) ProcessPeerList(addrs []string) {
+ for _, addr := range addrs {
+ // TODO Probably requires some sanity checks
+ s.ConnectToPeer(addr)
+ }
+}
+
+func (s *Ethereum) ConnectToPeer(addr string) error {
+ if s.peers.Len() < s.MaxPeers {
+ var alreadyConnected bool
+
+ ahost, _, _ := net.SplitHostPort(addr)
+ var chost string
+
+ ips, err := net.LookupIP(ahost)
+
+ if err != nil {
+ return err
+ } else {
+ // If more then one ip is available try stripping away the ipv6 ones
+ if len(ips) > 1 {
+ var ipsv4 []net.IP
+ // For now remove the ipv6 addresses
+ for _, ip := range ips {
+ if strings.Contains(ip.String(), "::") {
+ continue
+ } else {
+ ipsv4 = append(ipsv4, ip)
+ }
+ }
+ if len(ipsv4) == 0 {
+ return fmt.Errorf("[SERV] No IPV4 addresses available for hostname")
+ }
+
+ // Pick a random ipv4 address, simulating round-robin DNS.
+ rand.Seed(time.Now().UTC().UnixNano())
+ i := rand.Intn(len(ipsv4))
+ chost = ipsv4[i].String()
+ } else {
+ if len(ips) == 0 {
+ return fmt.Errorf("[SERV] No IPs resolved for the given hostname")
+ return nil
+ }
+ chost = ips[0].String()
+ }
+ }
+
+ eachPeer(s.peers, func(p *Peer, v *list.Element) {
+ if p.conn == nil {
+ return
+ }
+ phost, _, _ := net.SplitHostPort(p.conn.RemoteAddr().String())
+
+ if phost == chost {
+ alreadyConnected = true
+ //ethlogger.Debugf("Peer %s already added.\n", chost)
+ return
+ }
+ })
+
+ if alreadyConnected {
+ return nil
+ }
+
+ NewOutboundPeer(addr, s, s.serverCaps)
+ }
+
+ return nil
+}
+
+func (s *Ethereum) OutboundPeers() []*Peer {
+ // Create a new peer slice with at least the length of the total peers
+ outboundPeers := make([]*Peer, s.peers.Len())
+ length := 0
+ eachPeer(s.peers, func(p *Peer, e *list.Element) {
+ if !p.inbound && p.conn != nil {
+ outboundPeers[length] = p
+ length++
+ }
+ })
+
+ return outboundPeers[:length]
+}
+
+func (s *Ethereum) InboundPeers() []*Peer {
+ // Create a new peer slice with at least the length of the total peers
+ inboundPeers := make([]*Peer, s.peers.Len())
+ length := 0
+ eachPeer(s.peers, func(p *Peer, e *list.Element) {
+ if p.inbound {
+ inboundPeers[length] = p
+ length++
+ }
+ })
+
+ return inboundPeers[:length]
+}
+
+func (s *Ethereum) InOutPeers() []*Peer {
+ // Reap the dead peers first
+ s.reapPeers()
+
+ // Create a new peer slice with at least the length of the total peers
+ inboundPeers := make([]*Peer, s.peers.Len())
+ length := 0
+ eachPeer(s.peers, func(p *Peer, e *list.Element) {
+ // Only return peers with an actual ip
+ if len(p.host) > 0 {
+ inboundPeers[length] = p
+ length++
+ }
+ })
+
+ return inboundPeers[:length]
+}
+
+func (s *Ethereum) Broadcast(msgType ethwire.MsgType, data []interface{}) {
+ msg := ethwire.NewMessage(msgType, data)
+ s.BroadcastMsg(msg)
+}
+
+func (s *Ethereum) BroadcastMsg(msg *ethwire.Msg) {
+ eachPeer(s.peers, func(p *Peer, e *list.Element) {
+ p.QueueMessage(msg)
+ })
+}
+
+func (s *Ethereum) Peers() *list.List {
+ return s.peers
+}
+
+func (s *Ethereum) reapPeers() {
+ eachPeer(s.peers, func(p *Peer, e *list.Element) {
+ if atomic.LoadInt32(&p.disconnect) == 1 || (p.inbound && (time.Now().Unix()-p.lastPong) > int64(5*time.Minute)) {
+ s.removePeerElement(e)
+ }
+ })
+}
+
+func (s *Ethereum) removePeerElement(e *list.Element) {
+ s.peerMut.Lock()
+ defer s.peerMut.Unlock()
+
+ s.peers.Remove(e)
+
+ s.eventMux.Post(PeerListEvent{s.peers})
+}
+
+func (s *Ethereum) RemovePeer(p *Peer) {
+ eachPeer(s.peers, func(peer *Peer, e *list.Element) {
+ if peer == p {
+ s.removePeerElement(e)
+ }
+ })
+}
+
+func (s *Ethereum) reapDeadPeerHandler() {
+ reapTimer := time.NewTicker(processReapingTimeout * time.Second)
+
+ for {
+ select {
+ case <-reapTimer.C:
+ s.reapPeers()
+ }
+ }
+}
+
+// Start the ethereum
+func (s *Ethereum) Start(seed bool) {
+ s.blockPool.Start()
+ s.stateManager.Start()
+
+ // Bind to addr and port
+ ln, err := net.Listen("tcp", ":"+s.Port)
+ if err != nil {
+ ethlogger.Warnf("Port %s in use. Connection listening disabled. Acting as client", s.Port)
+ s.listening = false
+ } else {
+ s.listening = true
+ // Starting accepting connections
+ ethlogger.Infoln("Ready and accepting connections")
+ // Start the peer handler
+ go s.peerHandler(ln)
+ }
+
+ if s.nat != nil {
+ go s.upnpUpdateThread()
+ }
+
+ // Start the reaping processes
+ go s.reapDeadPeerHandler()
+ go s.update()
+ go s.filterLoop()
+
+ if seed {
+ s.Seed()
+ }
+ ethlogger.Infoln("Server started")
+}
+
+func (s *Ethereum) Seed() {
+ // Sorry Py person. I must blacklist. you perform badly
+ s.blacklist = append(s.blacklist, ethutil.Hex2Bytes("64656330303561383532336435376331616537643864663236623336313863373537353163636634333530626263396330346237336262623931383064393031"))
+ ips := PastPeers()
+ if len(ips) > 0 {
+ for _, ip := range ips {
+ ethlogger.Infoln("Connecting to previous peer ", ip)
+ s.ConnectToPeer(ip)
+ }
+ } else {
+ ethlogger.Debugln("Retrieving seed nodes")
+
+ // Eth-Go Bootstrapping
+ ips, er := net.LookupIP("seed.bysh.me")
+ if er == nil {
+ peers := []string{}
+ for _, ip := range ips {
+ node := fmt.Sprintf("%s:%d", ip.String(), 30303)
+ ethlogger.Debugln("Found DNS Go Peer:", node)
+ peers = append(peers, node)
+ }
+ s.ProcessPeerList(peers)
+ }
+
+ // Official DNS Bootstrapping
+ _, nodes, err := net.LookupSRV("eth", "tcp", "ethereum.org")
+ if err == nil {
+ peers := []string{}
+ // Iterate SRV nodes
+ for _, n := range nodes {
+ target := n.Target
+ port := strconv.Itoa(int(n.Port))
+ // Resolve target to ip (Go returns list, so may resolve to multiple ips?)
+ addr, err := net.LookupHost(target)
+ if err == nil {
+ for _, a := range addr {
+ // Build string out of SRV port and Resolved IP
+ peer := net.JoinHostPort(a, port)
+ ethlogger.Debugln("Found DNS Bootstrap Peer:", peer)
+ peers = append(peers, peer)
+ }
+ } else {
+ ethlogger.Debugln("Couldn't resolve :", target)
+ }
+ }
+ // Connect to Peer list
+ s.ProcessPeerList(peers)
+ }
+
+ // XXX tmp
+ s.ConnectToPeer(seedNodeAddress)
+ }
+}
+
+func (s *Ethereum) peerHandler(listener net.Listener) {
+ for {
+ conn, err := listener.Accept()
+ if err != nil {
+ ethlogger.Debugln(err)
+
+ continue
+ }
+
+ go s.AddPeer(conn)
+ }
+}
+
+func (s *Ethereum) Stop() {
+ // Close the database
+ defer s.db.Close()
+
+ var ips []string
+ eachPeer(s.peers, func(p *Peer, e *list.Element) {
+ ips = append(ips, p.conn.RemoteAddr().String())
+ })
+
+ if len(ips) > 0 {
+ d, _ := json.MarshalIndent(ips, "", " ")
+ ethutil.WriteFile(path.Join(ethutil.Config.ExecPath, "known_peers.json"), d)
+ }
+
+ eachPeer(s.peers, func(p *Peer, e *list.Element) {
+ p.Stop()
+ })
+
+ close(s.quit)
+
+ if s.RpcServer != nil {
+ s.RpcServer.Stop()
+ }
+ s.txPool.Stop()
+ s.stateManager.Stop()
+ s.eventMux.Stop()
+ s.blockPool.Stop()
+
+ ethlogger.Infoln("Server stopped")
+ close(s.shutdownChan)
+}
+
+// This function will wait for a shutdown and resumes main thread execution
+func (s *Ethereum) WaitForShutdown() {
+ <-s.shutdownChan
+}
+
+func (s *Ethereum) upnpUpdateThread() {
+ // Go off immediately to prevent code duplication, thereafter we renew
+ // lease every 15 minutes.
+ timer := time.NewTimer(5 * time.Minute)
+ lport, _ := strconv.ParseInt(s.Port, 10, 16)
+ first := true
+out:
+ for {
+ select {
+ case <-timer.C:
+ var err error
+ _, err = s.nat.AddPortMapping("TCP", int(lport), int(lport), "eth listen port", 20*60)
+ if err != nil {
+ ethlogger.Debugln("can't add UPnP port mapping:", err)
+ break out
+ }
+ if first && err == nil {
+ _, err = s.nat.GetExternalAddress()
+ if err != nil {
+ ethlogger.Debugln("UPnP can't get external address:", err)
+ continue out
+ }
+ first = false
+ }
+ timer.Reset(time.Minute * 15)
+ case <-s.quit:
+ break out
+ }
+ }
+
+ timer.Stop()
+
+ if err := s.nat.DeletePortMapping("TCP", int(lport), int(lport)); err != nil {
+ ethlogger.Debugln("unable to remove UPnP port mapping:", err)
+ } else {
+ ethlogger.Debugln("succesfully disestablished UPnP port mapping")
+ }
+}
+
+func (self *Ethereum) update() {
+ upToDateTimer := time.NewTicker(1 * time.Second)
+
+out:
+ for {
+ select {
+ case <-upToDateTimer.C:
+ if self.IsUpToDate() && !self.isUpToDate {
+ self.eventMux.Post(ChainSyncEvent{false})
+ self.isUpToDate = true
+ } else if !self.IsUpToDate() && self.isUpToDate {
+ self.eventMux.Post(ChainSyncEvent{true})
+ self.isUpToDate = false
+ }
+ case <-self.quit:
+ break out
+ }
+ }
+}
+
+// InstallFilter adds filter for blockchain events.
+// The filter's callbacks will run for matching blocks and messages.
+// The filter should not be modified after it has been installed.
+func (self *Ethereum) InstallFilter(filter *ethchain.Filter) (id int) {
+ self.filterMu.Lock()
+ id = self.filterId
+ self.filters[id] = filter
+ self.filterId++
+ self.filterMu.Unlock()
+ return id
+}
+
+func (self *Ethereum) UninstallFilter(id int) {
+ self.filterMu.Lock()
+ delete(self.filters, id)
+ self.filterMu.Unlock()
+}
+
+// GetFilter retrieves a filter installed using InstallFilter.
+// The filter may not be modified.
+func (self *Ethereum) GetFilter(id int) *ethchain.Filter {
+ self.filterMu.RLock()
+ defer self.filterMu.RUnlock()
+ return self.filters[id]
+}
+
+func (self *Ethereum) filterLoop() {
+ // Subscribe to events
+ events := self.eventMux.Subscribe(ethchain.NewBlockEvent{}, ethstate.Messages(nil))
+ for event := range events.Chan() {
+ switch event := event.(type) {
+ case ethchain.NewBlockEvent:
+ self.filterMu.RLock()
+ for _, filter := range self.filters {
+ if filter.BlockCallback != nil {
+ filter.BlockCallback(event.Block)
+ }
+ }
+ self.filterMu.RUnlock()
+
+ case ethstate.Messages:
+ self.filterMu.RLock()
+ for _, filter := range self.filters {
+ if filter.MessageCallback != nil {
+ msgs := filter.FilterMessages(event)
+ if len(msgs) > 0 {
+ filter.MessageCallback(msgs)
+ }
+ }
+ }
+ self.filterMu.RUnlock()
+ }
+ }
+}
+
+func bootstrapDb(db ethutil.Database) {
+ d, _ := db.Get([]byte("ProtocolVersion"))
+ protov := ethutil.NewValue(d).Uint()
+
+ if protov == 0 {
+ db.Put([]byte("ProtocolVersion"), ethutil.NewValue(ProtocolVersion).Bytes())
+ }
+}
+
+func PastPeers() []string {
+ var ips []string
+ data, _ := ethutil.ReadAllFile(path.Join(ethutil.Config.ExecPath, "known_peers.json"))
+ json.Unmarshal([]byte(data), &ips)
+
+ return ips
+}
diff --git a/ethlog/example_test.go b/ethlog/example_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..2532f36c134ee99310cb4aafc1f5891b0fc832b5
--- /dev/null
+++ b/ethlog/example_test.go
@@ -0,0 +1,21 @@
+package ethlog
+
+import "os"
+
+func ExampleLogger() {
+ logger := NewLogger("TAG")
+ logger.Infoln("so awesome") // prints [TAG] so awesome
+ logger.Infof("this %q is raw", "coin") // prints [TAG] this "coin" is raw
+}
+
+func ExampleLogSystem() {
+ filename := "test.log"
+ file, _ := os.OpenFile(filename, os.O_RDWR|os.O_CREATE, os.ModePerm)
+ fileLog := NewStdLogSystem(file, 0, WarnLevel)
+ AddLogSystem(fileLog)
+
+ stdoutLog := NewStdLogSystem(os.Stdout, 0, WarnLevel)
+ AddLogSystem(stdoutLog)
+
+ NewLogger("TAG").Warnln("reactor meltdown") // writes to both logs
+}
diff --git a/ethlog/loggers.go b/ethlog/loggers.go
new file mode 100644
index 0000000000000000000000000000000000000000..986bb17597aeda6c9b834c84615a4d81d6a2434d
--- /dev/null
+++ b/ethlog/loggers.go
@@ -0,0 +1,248 @@
+/*
+Package ethlog implements a multi-output leveled logger.
+
+Other packages use tagged logger to send log messages to shared
+(process-wide) logging engine. The shared logging engine dispatches to
+multiple log systems. The log level can be set separately per log
+system.
+
+Logging is asynchronous and does not block the caller. Message
+formatting is performed by the caller goroutine to avoid incorrect
+logging of mutable state.
+*/
+package ethlog
+
+import (
+ "fmt"
+ "io"
+ "log"
+ "os"
+ "sync"
+ "sync/atomic"
+)
+
+// LogSystem is implemented by log output devices.
+// All methods can be called concurrently from multiple goroutines.
+type LogSystem interface {
+ GetLogLevel() LogLevel
+ SetLogLevel(i LogLevel)
+ LogPrint(LogLevel, string)
+}
+
+type message struct {
+ level LogLevel
+ msg string
+}
+
+type LogLevel uint8
+
+const (
+ // Standard log levels
+ Silence LogLevel = iota
+ ErrorLevel
+ WarnLevel
+ InfoLevel
+ DebugLevel
+ DebugDetailLevel
+)
+
+var (
+ logMessageC = make(chan message)
+ addSystemC = make(chan LogSystem)
+ flushC = make(chan chan struct{})
+ resetC = make(chan chan struct{})
+)
+
+func init() {
+ go dispatchLoop()
+}
+
+// each system can buffer this many messages before
+// blocking incoming log messages.
+const sysBufferSize = 500
+
+func dispatchLoop() {
+ var (
+ systems []LogSystem
+ systemIn []chan message
+ systemWG sync.WaitGroup
+ )
+ bootSystem := func(sys LogSystem) {
+ in := make(chan message, sysBufferSize)
+ systemIn = append(systemIn, in)
+ systemWG.Add(1)
+ go sysLoop(sys, in, &systemWG)
+ }
+
+ for {
+ select {
+ case msg := <-logMessageC:
+ for _, c := range systemIn {
+ c <- msg
+ }
+
+ case sys := <-addSystemC:
+ systems = append(systems, sys)
+ bootSystem(sys)
+
+ case waiter := <-resetC:
+ // reset means terminate all systems
+ for _, c := range systemIn {
+ close(c)
+ }
+ systems = nil
+ systemIn = nil
+ systemWG.Wait()
+ close(waiter)
+
+ case waiter := <-flushC:
+ // flush means reboot all systems
+ for _, c := range systemIn {
+ close(c)
+ }
+ systemIn = nil
+ systemWG.Wait()
+ for _, sys := range systems {
+ bootSystem(sys)
+ }
+ close(waiter)
+ }
+ }
+}
+
+func sysLoop(sys LogSystem, in <-chan message, wg *sync.WaitGroup) {
+ for msg := range in {
+ if sys.GetLogLevel() >= msg.level {
+ sys.LogPrint(msg.level, msg.msg)
+ }
+ }
+ wg.Done()
+}
+
+// Reset removes all active log systems.
+// It blocks until all current messages have been delivered.
+func Reset() {
+ waiter := make(chan struct{})
+ resetC <- waiter
+ <-waiter
+}
+
+// Flush waits until all current log messages have been dispatched to
+// the active log systems.
+func Flush() {
+ waiter := make(chan struct{})
+ flushC <- waiter
+ <-waiter
+}
+
+// AddLogSystem starts printing messages to the given LogSystem.
+func AddLogSystem(sys LogSystem) {
+ addSystemC <- sys
+}
+
+// A Logger prints messages prefixed by a given tag. It provides named
+// Printf and Println style methods for all loglevels. Each ethereum
+// component should have its own logger with a unique prefix.
+type Logger struct {
+ tag string
+}
+
+func NewLogger(tag string) *Logger {
+ return &Logger{"[" + tag + "] "}
+}
+
+func (logger *Logger) sendln(level LogLevel, v ...interface{}) {
+ logMessageC <- message{level, logger.tag + fmt.Sprintln(v...)}
+}
+
+func (logger *Logger) sendf(level LogLevel, format string, v ...interface{}) {
+ logMessageC <- message{level, logger.tag + fmt.Sprintf(format, v...)}
+}
+
+// Errorln writes a message with ErrorLevel.
+func (logger *Logger) Errorln(v ...interface{}) {
+ logger.sendln(ErrorLevel, v...)
+}
+
+// Warnln writes a message with WarnLevel.
+func (logger *Logger) Warnln(v ...interface{}) {
+ logger.sendln(WarnLevel, v...)
+}
+
+// Infoln writes a message with InfoLevel.
+func (logger *Logger) Infoln(v ...interface{}) {
+ logger.sendln(InfoLevel, v...)
+}
+
+// Debugln writes a message with DebugLevel.
+func (logger *Logger) Debugln(v ...interface{}) {
+ logger.sendln(DebugLevel, v...)
+}
+
+// DebugDetailln writes a message with DebugDetailLevel.
+func (logger *Logger) DebugDetailln(v ...interface{}) {
+ logger.sendln(DebugDetailLevel, v...)
+}
+
+// Errorf writes a message with ErrorLevel.
+func (logger *Logger) Errorf(format string, v ...interface{}) {
+ logger.sendf(ErrorLevel, format, v...)
+}
+
+// Warnf writes a message with WarnLevel.
+func (logger *Logger) Warnf(format string, v ...interface{}) {
+ logger.sendf(WarnLevel, format, v...)
+}
+
+// Infof writes a message with InfoLevel.
+func (logger *Logger) Infof(format string, v ...interface{}) {
+ logger.sendf(InfoLevel, format, v...)
+}
+
+// Debugf writes a message with DebugLevel.
+func (logger *Logger) Debugf(format string, v ...interface{}) {
+ logger.sendf(DebugLevel, format, v...)
+}
+
+// DebugDetailf writes a message with DebugDetailLevel.
+func (logger *Logger) DebugDetailf(format string, v ...interface{}) {
+ logger.sendf(DebugDetailLevel, format, v...)
+}
+
+// Fatalln writes a message with ErrorLevel and exits the program.
+func (logger *Logger) Fatalln(v ...interface{}) {
+ logger.sendln(ErrorLevel, v...)
+ Flush()
+ os.Exit(0)
+}
+
+// Fatalf writes a message with ErrorLevel and exits the program.
+func (logger *Logger) Fatalf(format string, v ...interface{}) {
+ logger.sendf(ErrorLevel, format, v...)
+ Flush()
+ os.Exit(0)
+}
+
+// NewStdLogSystem creates a LogSystem that prints to the given writer.
+// The flag values are defined package log.
+func NewStdLogSystem(writer io.Writer, flags int, level LogLevel) LogSystem {
+ logger := log.New(writer, "", flags)
+ return &stdLogSystem{logger, uint32(level)}
+}
+
+type stdLogSystem struct {
+ logger *log.Logger
+ level uint32
+}
+
+func (t *stdLogSystem) LogPrint(level LogLevel, msg string) {
+ t.logger.Print(msg)
+}
+
+func (t *stdLogSystem) SetLogLevel(i LogLevel) {
+ atomic.StoreUint32(&t.level, uint32(i))
+}
+
+func (t *stdLogSystem) GetLogLevel() LogLevel {
+ return LogLevel(atomic.LoadUint32(&t.level))
+}
diff --git a/ethlog/loggers_test.go b/ethlog/loggers_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..cf92e3cc66def0c898d42e1022ccaf4601ffeedc
--- /dev/null
+++ b/ethlog/loggers_test.go
@@ -0,0 +1,174 @@
+package ethlog
+
+import (
+ "io/ioutil"
+ "math/rand"
+ "os"
+ "sync"
+ "testing"
+ "time"
+)
+
+type TestLogSystem struct {
+ mutex sync.Mutex
+ output string
+ level LogLevel
+}
+
+func (ls *TestLogSystem) LogPrint(level LogLevel, msg string) {
+ ls.mutex.Lock()
+ ls.output += msg
+ ls.mutex.Unlock()
+}
+
+func (ls *TestLogSystem) SetLogLevel(i LogLevel) {
+ ls.mutex.Lock()
+ ls.level = i
+ ls.mutex.Unlock()
+}
+
+func (ls *TestLogSystem) GetLogLevel() LogLevel {
+ ls.mutex.Lock()
+ defer ls.mutex.Unlock()
+ return ls.level
+}
+
+func (ls *TestLogSystem) CheckOutput(t *testing.T, expected string) {
+ ls.mutex.Lock()
+ output := ls.output
+ ls.mutex.Unlock()
+ if output != expected {
+ t.Errorf("log output mismatch:\n got: %q\n want: %q\n", output, expected)
+ }
+}
+
+type blockedLogSystem struct {
+ LogSystem
+ unblock chan struct{}
+}
+
+func (ls blockedLogSystem) LogPrint(level LogLevel, msg string) {
+ <-ls.unblock
+ ls.LogSystem.LogPrint(level, msg)
+}
+
+func TestLoggerFlush(t *testing.T) {
+ Reset()
+
+ logger := NewLogger("TEST")
+ ls := blockedLogSystem{&TestLogSystem{level: WarnLevel}, make(chan struct{})}
+ AddLogSystem(ls)
+ for i := 0; i < 5; i++ {
+ // these writes shouldn't hang even though ls is blocked
+ logger.Errorf(".")
+ }
+
+ beforeFlush := time.Now()
+ time.AfterFunc(80*time.Millisecond, func() { close(ls.unblock) })
+ Flush() // this should hang for approx. 80ms
+ if blockd := time.Now().Sub(beforeFlush); blockd < 80*time.Millisecond {
+ t.Errorf("Flush didn't block long enough, blocked for %v, should've been >= 80ms", blockd)
+ }
+
+ ls.LogSystem.(*TestLogSystem).CheckOutput(t, "[TEST] .[TEST] .[TEST] .[TEST] .[TEST] .")
+}
+
+func TestLoggerPrintln(t *testing.T) {
+ Reset()
+
+ logger := NewLogger("TEST")
+ testLogSystem := &TestLogSystem{level: WarnLevel}
+ AddLogSystem(testLogSystem)
+ logger.Errorln("error")
+ logger.Warnln("warn")
+ logger.Infoln("info")
+ logger.Debugln("debug")
+ Flush()
+
+ testLogSystem.CheckOutput(t, "[TEST] error\n[TEST] warn\n")
+}
+
+func TestLoggerPrintf(t *testing.T) {
+ Reset()
+
+ logger := NewLogger("TEST")
+ testLogSystem := &TestLogSystem{level: WarnLevel}
+ AddLogSystem(testLogSystem)
+ logger.Errorf("error to %v\n", []int{1, 2, 3})
+ logger.Warnf("warn %%d %d", 5)
+ logger.Infof("info")
+ logger.Debugf("debug")
+ Flush()
+ testLogSystem.CheckOutput(t, "[TEST] error to [1 2 3]\n[TEST] warn %d 5")
+}
+
+func TestMultipleLogSystems(t *testing.T) {
+ Reset()
+
+ logger := NewLogger("TEST")
+ testLogSystem0 := &TestLogSystem{level: ErrorLevel}
+ testLogSystem1 := &TestLogSystem{level: WarnLevel}
+ AddLogSystem(testLogSystem0)
+ AddLogSystem(testLogSystem1)
+ logger.Errorln("error")
+ logger.Warnln("warn")
+ Flush()
+
+ testLogSystem0.CheckOutput(t, "[TEST] error\n")
+ testLogSystem1.CheckOutput(t, "[TEST] error\n[TEST] warn\n")
+}
+
+func TestFileLogSystem(t *testing.T) {
+ Reset()
+
+ logger := NewLogger("TEST")
+ filename := "test.log"
+ file, _ := os.OpenFile(filename, os.O_RDWR|os.O_CREATE, os.ModePerm)
+ testLogSystem := NewStdLogSystem(file, 0, WarnLevel)
+ AddLogSystem(testLogSystem)
+ logger.Errorf("error to %s\n", filename)
+ logger.Warnln("warn")
+ Flush()
+ contents, _ := ioutil.ReadFile(filename)
+ output := string(contents)
+ if output != "[TEST] error to test.log\n[TEST] warn\n" {
+ t.Error("Expected contents of file 'test.log': '[TEST] error to test.log\\n[TEST] warn\\n', got ", output)
+ } else {
+ os.Remove(filename)
+ }
+}
+
+func TestNoLogSystem(t *testing.T) {
+ Reset()
+
+ logger := NewLogger("TEST")
+ logger.Warnln("warn")
+ Flush()
+}
+
+func TestConcurrentAddSystem(t *testing.T) {
+ rand.Seed(time.Now().Unix())
+ Reset()
+
+ logger := NewLogger("TEST")
+ stop := make(chan struct{})
+ writer := func() {
+ select {
+ case <-stop:
+ return
+ default:
+ logger.Infoln("foo")
+ Flush()
+ }
+ }
+
+ go writer()
+ go writer()
+
+ stopTime := time.Now().Add(100 * time.Millisecond)
+ for time.Now().Before(stopTime) {
+ time.Sleep(time.Duration(rand.Intn(20)) * time.Millisecond)
+ AddLogSystem(NewStdLogSystem(ioutil.Discard, 0, InfoLevel))
+ }
+ close(stop)
+}
diff --git a/ethminer/miner.go b/ethminer/miner.go
new file mode 100644
index 0000000000000000000000000000000000000000..9fca9961a85362f34eb81fda44371e679562f5dc
--- /dev/null
+++ b/ethminer/miner.go
@@ -0,0 +1,214 @@
+package ethminer
+
+import (
+ "bytes"
+ "sort"
+
+ "github.com/ethereum/go-ethereum/ethchain"
+ "github.com/ethereum/go-ethereum/ethlog"
+ "github.com/ethereum/go-ethereum/ethwire"
+ "github.com/ethereum/go-ethereum/event"
+)
+
+var logger = ethlog.NewLogger("MINER")
+
+type Miner struct {
+ pow ethchain.PoW
+ ethereum ethchain.EthManager
+ coinbase []byte
+ txs ethchain.Transactions
+ uncles []*ethchain.Block
+ block *ethchain.Block
+
+ events event.Subscription
+ powQuitChan chan struct{}
+ powDone chan struct{}
+
+ turbo bool
+}
+
+const (
+ Started = iota
+ Stopped
+)
+
+type Event struct {
+ Type int // Started || Stopped
+ Miner *Miner
+}
+
+func (self *Miner) GetPow() ethchain.PoW {
+ return self.pow
+}
+
+func NewDefaultMiner(coinbase []byte, ethereum ethchain.EthManager) *Miner {
+ miner := Miner{
+ pow: ðchain.EasyPow{},
+ ethereum: ethereum,
+ coinbase: coinbase,
+ }
+
+ return &miner
+}
+
+func (self *Miner) ToggleTurbo() {
+ self.turbo = !self.turbo
+
+ self.pow.Turbo(self.turbo)
+}
+
+func (miner *Miner) Start() {
+
+ // Insert initial TXs in our little miner 'pool'
+ miner.txs = miner.ethereum.TxPool().Flush()
+ miner.block = miner.ethereum.ChainManager().NewBlock(miner.coinbase)
+
+ mux := miner.ethereum.EventMux()
+ miner.events = mux.Subscribe(ethchain.NewBlockEvent{}, ethchain.TxEvent{})
+
+ // Prepare inital block
+ //miner.ethereum.StateManager().Prepare(miner.block.State(), miner.block.State())
+ go miner.listener()
+
+ logger.Infoln("Started")
+ mux.Post(Event{Started, miner})
+}
+
+func (miner *Miner) Stop() {
+ logger.Infoln("Stopping...")
+ miner.events.Unsubscribe()
+ miner.ethereum.EventMux().Post(Event{Stopped, miner})
+}
+
+func (miner *Miner) listener() {
+ for {
+ miner.startMining()
+
+ select {
+ case event, isopen := <-miner.events.Chan():
+ miner.stopMining()
+ if !isopen {
+ return
+ }
+
+ switch event := event.(type) {
+ case ethchain.NewBlockEvent:
+ block := event.Block
+ //logger.Infoln("Got new block via Reactor")
+ if bytes.Compare(miner.ethereum.ChainManager().CurrentBlock.Hash(), block.Hash()) == 0 {
+ // TODO: Perhaps continue mining to get some uncle rewards
+ //logger.Infoln("New top block found resetting state")
+
+ // Filter out which Transactions we have that were not in this block
+ var newtxs []*ethchain.Transaction
+ for _, tx := range miner.txs {
+ found := false
+ for _, othertx := range block.Transactions() {
+ if bytes.Compare(tx.Hash(), othertx.Hash()) == 0 {
+ found = true
+ }
+ }
+ if found == false {
+ newtxs = append(newtxs, tx)
+ }
+ }
+ miner.txs = newtxs
+
+ // Setup a fresh state to mine on
+ //miner.block = miner.ethereum.ChainManager().NewBlock(miner.coinbase, miner.txs)
+
+ } else {
+ if bytes.Compare(block.PrevHash, miner.ethereum.ChainManager().CurrentBlock.PrevHash) == 0 {
+ logger.Infoln("Adding uncle block")
+ miner.uncles = append(miner.uncles, block)
+ }
+ }
+
+ case ethchain.TxEvent:
+ if event.Type == ethchain.TxPre {
+ found := false
+ for _, ctx := range miner.txs {
+ if found = bytes.Compare(ctx.Hash(), event.Tx.Hash()) == 0; found {
+ break
+ }
+ }
+ if found == false {
+ // Undo all previous commits
+ miner.block.Undo()
+ // Apply new transactions
+ miner.txs = append(miner.txs, event.Tx)
+ }
+ }
+ }
+
+ case <-miner.powDone:
+ // next iteration will start mining again
+ }
+ }
+}
+
+func (miner *Miner) startMining() {
+ if miner.powDone == nil {
+ miner.powDone = make(chan struct{})
+ }
+ miner.powQuitChan = make(chan struct{})
+ go miner.mineNewBlock()
+}
+
+func (miner *Miner) stopMining() {
+ close(miner.powQuitChan)
+ <-miner.powDone
+}
+
+func (self *Miner) mineNewBlock() {
+ stateManager := self.ethereum.StateManager()
+
+ self.block = self.ethereum.ChainManager().NewBlock(self.coinbase)
+
+ // Apply uncles
+ if len(self.uncles) > 0 {
+ self.block.SetUncles(self.uncles)
+ }
+
+ // Sort the transactions by nonce in case of odd network propagation
+ sort.Sort(ethchain.TxByNonce{self.txs})
+
+ // Accumulate all valid transactions and apply them to the new state
+ // Error may be ignored. It's not important during mining
+ parent := self.ethereum.ChainManager().GetBlock(self.block.PrevHash)
+ coinbase := self.block.State().GetOrNewStateObject(self.block.Coinbase)
+ coinbase.SetGasPool(self.block.CalcGasLimit(parent))
+ receipts, txs, unhandledTxs, err := stateManager.ProcessTransactions(coinbase, self.block.State(), self.block, self.block, self.txs)
+ if err != nil {
+ logger.Debugln(err)
+ }
+ self.txs = append(txs, unhandledTxs...)
+ self.block.SetTxHash(receipts)
+
+ // Set the transactions to the block so the new SHA3 can be calculated
+ self.block.SetReceipts(receipts, txs)
+
+ // Accumulate the rewards included for this block
+ stateManager.AccumelateRewards(self.block.State(), self.block, parent)
+
+ self.block.State().Update()
+
+ logger.Infof("Mining on block. Includes %v transactions", len(self.txs))
+
+ // Find a valid nonce
+ nonce := self.pow.Search(self.block, self.powQuitChan)
+ if nonce != nil {
+ self.block.Nonce = nonce
+ err := self.ethereum.StateManager().Process(self.block, false)
+ if err != nil {
+ logger.Infoln(err)
+ } else {
+ self.ethereum.Broadcast(ethwire.MsgBlockTy, []interface{}{self.block.Value().Val})
+ logger.Infof("🔨 Mined block %x\n", self.block.Hash())
+ logger.Infoln(self.block)
+ // Gather the new batch of transactions currently in the tx pool
+ self.txs = self.ethereum.TxPool().CurrentTransactions()
+ }
+ }
+ self.powDone <- struct{}{}
+}
diff --git a/ethpipe/config.go b/ethpipe/config.go
new file mode 100644
index 0000000000000000000000000000000000000000..bea5005b6dbb76d3f64ca0a0e6713abe5e1e141c
--- /dev/null
+++ b/ethpipe/config.go
@@ -0,0 +1,33 @@
+package ethpipe
+
+import "github.com/ethereum/go-ethereum/ethutil"
+
+var cnfCtr = ethutil.Hex2Bytes("661005d2720d855f1d9976f88bb10c1a3398c77f")
+
+type Config struct {
+ pipe *Pipe
+}
+
+func (self *Config) Get(name string) *Object {
+ configCtrl := self.pipe.World().safeGet(cnfCtr)
+ var addr []byte
+
+ switch name {
+ case "NameReg":
+ addr = []byte{0}
+ case "DnsReg":
+ objectAddr := configCtrl.GetStorage(ethutil.BigD([]byte{0}))
+ domainAddr := (&Object{self.pipe.World().safeGet(objectAddr.Bytes())}).StorageString("DnsReg").Bytes()
+ return &Object{self.pipe.World().safeGet(domainAddr)}
+ default:
+ addr = ethutil.RightPadBytes([]byte(name), 32)
+ }
+
+ objectAddr := configCtrl.GetStorage(ethutil.BigD(addr))
+
+ return &Object{self.pipe.World().safeGet(objectAddr.Bytes())}
+}
+
+func (self *Config) Exist() bool {
+ return self.pipe.World().Get(cnfCtr) != nil
+}
diff --git a/ethpipe/js_pipe.go b/ethpipe/js_pipe.go
new file mode 100644
index 0000000000000000000000000000000000000000..4b4369768d0c310862339ba5d3fa6f69593134ad
--- /dev/null
+++ b/ethpipe/js_pipe.go
@@ -0,0 +1,264 @@
+package ethpipe
+
+import (
+ "bytes"
+ "encoding/json"
+ "sync/atomic"
+
+ "github.com/ethereum/go-ethereum/ethchain"
+ "github.com/ethereum/go-ethereum/ethcrypto"
+ "github.com/ethereum/go-ethereum/ethstate"
+ "github.com/ethereum/go-ethereum/ethutil"
+)
+
+type JSPipe struct {
+ *Pipe
+}
+
+func NewJSPipe(eth ethchain.EthManager) *JSPipe {
+ return &JSPipe{New(eth)}
+}
+
+func (self *JSPipe) BlockByHash(strHash string) *JSBlock {
+ hash := ethutil.Hex2Bytes(strHash)
+ block := self.obj.ChainManager().GetBlock(hash)
+
+ return NewJSBlock(block)
+}
+
+func (self *JSPipe) BlockByNumber(num int32) *JSBlock {
+ if num == -1 {
+ return NewJSBlock(self.obj.ChainManager().CurrentBlock)
+ }
+
+ return NewJSBlock(self.obj.ChainManager().GetBlockByNumber(uint64(num)))
+}
+
+func (self *JSPipe) Block(v interface{}) *JSBlock {
+ if n, ok := v.(int32); ok {
+ return self.BlockByNumber(n)
+ } else if str, ok := v.(string); ok {
+ return self.BlockByHash(str)
+ } else if f, ok := v.(float64); ok { // Don't ask ...
+ return self.BlockByNumber(int32(f))
+ }
+
+ return nil
+}
+
+func (self *JSPipe) Key() *JSKey {
+ return NewJSKey(self.obj.KeyManager().KeyPair())
+}
+
+func (self *JSPipe) StateObject(addr string) *JSObject {
+ object := &Object{self.World().safeGet(ethutil.Hex2Bytes(addr))}
+
+ return NewJSObject(object)
+}
+
+func (self *JSPipe) PeerCount() int {
+ return self.obj.PeerCount()
+}
+
+func (self *JSPipe) Peers() []JSPeer {
+ var peers []JSPeer
+ for peer := self.obj.Peers().Front(); peer != nil; peer = peer.Next() {
+ p := peer.Value.(ethchain.Peer)
+ // we only want connected peers
+ if atomic.LoadInt32(p.Connected()) != 0 {
+ peers = append(peers, *NewJSPeer(p))
+ }
+ }
+
+ return peers
+}
+
+func (self *JSPipe) IsMining() bool {
+ return self.obj.IsMining()
+}
+
+func (self *JSPipe) IsListening() bool {
+ return self.obj.IsListening()
+}
+
+func (self *JSPipe) CoinBase() string {
+ return ethutil.Bytes2Hex(self.obj.KeyManager().Address())
+}
+
+func (self *JSPipe) NumberToHuman(balance string) string {
+ b := ethutil.Big(balance)
+
+ return ethutil.CurrencyToString(b)
+}
+
+func (self *JSPipe) StorageAt(addr, storageAddr string) string {
+ storage := self.World().SafeGet(ethutil.Hex2Bytes(addr)).Storage(ethutil.Hex2Bytes(storageAddr))
+
+ return ethutil.Bytes2Hex(storage.Bytes())
+}
+
+func (self *JSPipe) BalanceAt(addr string) string {
+ return self.World().SafeGet(ethutil.Hex2Bytes(addr)).Balance().String()
+}
+
+func (self *JSPipe) TxCountAt(address string) int {
+ return int(self.World().SafeGet(ethutil.Hex2Bytes(address)).Nonce)
+}
+
+func (self *JSPipe) CodeAt(address string) string {
+ return ethutil.Bytes2Hex(self.World().SafeGet(ethutil.Hex2Bytes(address)).Code)
+}
+
+func (self *JSPipe) IsContract(address string) bool {
+ return len(self.World().SafeGet(ethutil.Hex2Bytes(address)).Code) > 0
+}
+
+func (self *JSPipe) SecretToAddress(key string) string {
+ pair, err := ethcrypto.NewKeyPairFromSec(ethutil.Hex2Bytes(key))
+ if err != nil {
+ return ""
+ }
+
+ return ethutil.Bytes2Hex(pair.Address())
+}
+
+func (self *JSPipe) Execute(addr, value, gas, price, data string) (string, error) {
+ ret, err := self.ExecuteObject(&Object{
+ self.World().safeGet(ethutil.Hex2Bytes(addr))},
+ ethutil.Hex2Bytes(data),
+ ethutil.NewValue(value),
+ ethutil.NewValue(gas),
+ ethutil.NewValue(price),
+ )
+
+ return ethutil.Bytes2Hex(ret), err
+}
+
+type KeyVal struct {
+ Key string `json:"key"`
+ Value string `json:"value"`
+}
+
+func (self *JSPipe) EachStorage(addr string) string {
+ var values []KeyVal
+ object := self.World().SafeGet(ethutil.Hex2Bytes(addr))
+ object.EachStorage(func(name string, value *ethutil.Value) {
+ value.Decode()
+ values = append(values, KeyVal{ethutil.Bytes2Hex([]byte(name)), ethutil.Bytes2Hex(value.Bytes())})
+ })
+
+ valuesJson, err := json.Marshal(values)
+ if err != nil {
+ return ""
+ }
+
+ return string(valuesJson)
+}
+
+func (self *JSPipe) ToAscii(str string) string {
+ padded := ethutil.RightPadBytes([]byte(str), 32)
+
+ return "0x" + ethutil.Bytes2Hex(padded)
+}
+
+func (self *JSPipe) FromAscii(str string) string {
+ if ethutil.IsHex(str) {
+ str = str[2:]
+ }
+
+ return string(bytes.Trim(ethutil.Hex2Bytes(str), "\x00"))
+}
+
+func (self *JSPipe) FromNumber(str string) string {
+ if ethutil.IsHex(str) {
+ str = str[2:]
+ }
+
+ return ethutil.BigD(ethutil.Hex2Bytes(str)).String()
+}
+
+func (self *JSPipe) Transact(key, toStr, valueStr, gasStr, gasPriceStr, codeStr string) (*JSReceipt, error) {
+ var hash []byte
+ var contractCreation bool
+ if len(toStr) == 0 {
+ contractCreation = true
+ } else {
+ // Check if an address is stored by this address
+ addr := self.World().Config().Get("NameReg").StorageString(toStr).Bytes()
+ if len(addr) > 0 {
+ hash = addr
+ } else {
+ hash = ethutil.Hex2Bytes(toStr)
+ }
+ }
+
+ var keyPair *ethcrypto.KeyPair
+ var err error
+ if ethutil.IsHex(key) {
+ keyPair, err = ethcrypto.NewKeyPairFromSec([]byte(ethutil.Hex2Bytes(key[2:])))
+ } else {
+ keyPair, err = ethcrypto.NewKeyPairFromSec([]byte(ethutil.Hex2Bytes(key)))
+ }
+
+ if err != nil {
+ return nil, err
+ }
+
+ var (
+ value = ethutil.Big(valueStr)
+ gas = ethutil.Big(gasStr)
+ gasPrice = ethutil.Big(gasPriceStr)
+ data []byte
+ tx *ethchain.Transaction
+ )
+
+ if ethutil.IsHex(codeStr) {
+ data = ethutil.Hex2Bytes(codeStr[2:])
+ } else {
+ data = ethutil.Hex2Bytes(codeStr)
+ }
+
+ if contractCreation {
+ tx = ethchain.NewContractCreationTx(value, gas, gasPrice, data)
+ } else {
+ tx = ethchain.NewTransactionMessage(hash, value, gas, gasPrice, data)
+ }
+
+ acc := self.obj.StateManager().TransState().GetOrNewStateObject(keyPair.Address())
+ tx.Nonce = acc.Nonce
+ acc.Nonce += 1
+ self.obj.StateManager().TransState().UpdateStateObject(acc)
+
+ tx.Sign(keyPair.PrivateKey)
+ self.obj.TxPool().QueueTransaction(tx)
+
+ if contractCreation {
+ logger.Infof("Contract addr %x", tx.CreationAddress(self.World().State()))
+ }
+
+ return NewJSReciept(contractCreation, tx.CreationAddress(self.World().State()), tx.Hash(), keyPair.Address()), nil
+}
+
+func (self *JSPipe) PushTx(txStr string) (*JSReceipt, error) {
+ tx := ethchain.NewTransactionFromBytes(ethutil.Hex2Bytes(txStr))
+ self.obj.TxPool().QueueTransaction(tx)
+ return NewJSReciept(tx.CreatesContract(), tx.CreationAddress(self.World().State()), tx.Hash(), tx.Sender()), nil
+}
+
+func (self *JSPipe) CompileMutan(code string) string {
+ data, err := self.Pipe.CompileMutan(code)
+ if err != nil {
+ return err.Error()
+ }
+
+ return ethutil.Bytes2Hex(data)
+}
+
+func ToJSMessages(messages ethstate.Messages) *ethutil.List {
+ var msgs []JSMessage
+ for _, m := range messages {
+ msgs = append(msgs, NewJSMessage(m))
+ }
+
+ return ethutil.NewList(msgs)
+}
diff --git a/ethpipe/js_types.go b/ethpipe/js_types.go
new file mode 100644
index 0000000000000000000000000000000000000000..05c12fbf6c6d9d1287f55b4a1d2119a44f441a99
--- /dev/null
+++ b/ethpipe/js_types.go
@@ -0,0 +1,222 @@
+package ethpipe
+
+import (
+ "fmt"
+ "strconv"
+ "strings"
+
+ "github.com/ethereum/go-ethereum/ethchain"
+ "github.com/ethereum/go-ethereum/ethcrypto"
+ "github.com/ethereum/go-ethereum/ethstate"
+ "github.com/ethereum/go-ethereum/ethutil"
+)
+
+// Block interface exposed to QML
+type JSBlock struct {
+ //Transactions string `json:"transactions"`
+ ref *ethchain.Block
+ Size string `json:"size"`
+ Number int `json:"number"`
+ Hash string `json:"hash"`
+ Transactions *ethutil.List `json:"transactions"`
+ Time int64 `json:"time"`
+ Coinbase string `json:"coinbase"`
+ Name string `json:"name"`
+ GasLimit string `json:"gasLimit"`
+ GasUsed string `json:"gasUsed"`
+ PrevHash string `json:"prevHash"`
+}
+
+// Creates a new QML Block from a chain block
+func NewJSBlock(block *ethchain.Block) *JSBlock {
+ if block == nil {
+ return &JSBlock{}
+ }
+
+ var ptxs []*JSTransaction
+ for _, tx := range block.Transactions() {
+ ptxs = append(ptxs, NewJSTx(tx, block.State()))
+ }
+
+ list := ethutil.NewList(ptxs)
+
+ return &JSBlock{
+ ref: block, Size: block.Size().String(),
+ Number: int(block.Number.Uint64()), GasUsed: block.GasUsed.String(),
+ GasLimit: block.GasLimit.String(), Hash: ethutil.Bytes2Hex(block.Hash()),
+ Transactions: list, Time: block.Time,
+ Coinbase: ethutil.Bytes2Hex(block.Coinbase),
+ PrevHash: ethutil.Bytes2Hex(block.PrevHash),
+ }
+}
+
+func (self *JSBlock) ToString() string {
+ if self.ref != nil {
+ return self.ref.String()
+ }
+
+ return ""
+}
+
+func (self *JSBlock) GetTransaction(hash string) *JSTransaction {
+ tx := self.ref.GetTransaction(ethutil.Hex2Bytes(hash))
+ if tx == nil {
+ return nil
+ }
+
+ return NewJSTx(tx, self.ref.State())
+}
+
+type JSTransaction struct {
+ ref *ethchain.Transaction
+
+ Value string `json:"value"`
+ Gas string `json:"gas"`
+ GasPrice string `json:"gasPrice"`
+ Hash string `json:"hash"`
+ Address string `json:"address"`
+ Sender string `json:"sender"`
+ RawData string `json:"rawData"`
+ Data string `json:"data"`
+ Contract bool `json:"isContract"`
+ CreatesContract bool `json:"createsContract"`
+ Confirmations int `json:"confirmations"`
+}
+
+func NewJSTx(tx *ethchain.Transaction, state *ethstate.State) *JSTransaction {
+ hash := ethutil.Bytes2Hex(tx.Hash())
+ receiver := ethutil.Bytes2Hex(tx.Recipient)
+ if receiver == "0000000000000000000000000000000000000000" {
+ receiver = ethutil.Bytes2Hex(tx.CreationAddress(state))
+ }
+ sender := ethutil.Bytes2Hex(tx.Sender())
+ createsContract := tx.CreatesContract()
+
+ var data string
+ if tx.CreatesContract() {
+ data = strings.Join(ethchain.Disassemble(tx.Data), "\n")
+ } else {
+ data = ethutil.Bytes2Hex(tx.Data)
+ }
+
+ return &JSTransaction{ref: tx, Hash: hash, Value: ethutil.CurrencyToString(tx.Value), Address: receiver, Contract: tx.CreatesContract(), Gas: tx.Gas.String(), GasPrice: tx.GasPrice.String(), Data: data, Sender: sender, CreatesContract: createsContract, RawData: ethutil.Bytes2Hex(tx.Data)}
+}
+
+func (self *JSTransaction) ToString() string {
+ return self.ref.String()
+}
+
+type JSKey struct {
+ Address string `json:"address"`
+ PrivateKey string `json:"privateKey"`
+ PublicKey string `json:"publicKey"`
+}
+
+func NewJSKey(key *ethcrypto.KeyPair) *JSKey {
+ return &JSKey{ethutil.Bytes2Hex(key.Address()), ethutil.Bytes2Hex(key.PrivateKey), ethutil.Bytes2Hex(key.PublicKey)}
+}
+
+type JSObject struct {
+ *Object
+}
+
+func NewJSObject(object *Object) *JSObject {
+ return &JSObject{object}
+}
+
+type PReceipt struct {
+ CreatedContract bool `json:"createdContract"`
+ Address string `json:"address"`
+ Hash string `json:"hash"`
+ Sender string `json:"sender"`
+}
+
+func NewPReciept(contractCreation bool, creationAddress, hash, address []byte) *PReceipt {
+ return &PReceipt{
+ contractCreation,
+ ethutil.Bytes2Hex(creationAddress),
+ ethutil.Bytes2Hex(hash),
+ ethutil.Bytes2Hex(address),
+ }
+}
+
+// Peer interface exposed to QML
+
+type JSPeer struct {
+ ref *ethchain.Peer
+ Inbound bool `json:"isInbound"`
+ LastSend int64 `json:"lastSend"`
+ LastPong int64 `json:"lastPong"`
+ Ip string `json:"ip"`
+ Port int `json:"port"`
+ Version string `json:"version"`
+ LastResponse string `json:"lastResponse"`
+ Latency string `json:"latency"`
+ Caps string `json:"caps"`
+}
+
+func NewJSPeer(peer ethchain.Peer) *JSPeer {
+ if peer == nil {
+ return nil
+ }
+
+ var ip []string
+ for _, i := range peer.Host() {
+ ip = append(ip, strconv.Itoa(int(i)))
+ }
+ ipAddress := strings.Join(ip, ".")
+
+ var caps []string
+ capsIt := peer.Caps().NewIterator()
+ for capsIt.Next() {
+ caps = append(caps, capsIt.Value().Str())
+ }
+
+ return &JSPeer{ref: &peer, Inbound: peer.Inbound(), LastSend: peer.LastSend().Unix(), LastPong: peer.LastPong(), Version: peer.Version(), Ip: ipAddress, Port: int(peer.Port()), Latency: peer.PingTime(), Caps: fmt.Sprintf("%v", caps)}
+}
+
+type JSReceipt struct {
+ CreatedContract bool `json:"createdContract"`
+ Address string `json:"address"`
+ Hash string `json:"hash"`
+ Sender string `json:"sender"`
+}
+
+func NewJSReciept(contractCreation bool, creationAddress, hash, address []byte) *JSReceipt {
+ return &JSReceipt{
+ contractCreation,
+ ethutil.Bytes2Hex(creationAddress),
+ ethutil.Bytes2Hex(hash),
+ ethutil.Bytes2Hex(address),
+ }
+}
+
+type JSMessage struct {
+ To string `json:"to"`
+ From string `json:"from"`
+ Input string `json:"input"`
+ Output string `json:"output"`
+ Path int32 `json:"path"`
+ Origin string `json:"origin"`
+ Timestamp int32 `json:"timestamp"`
+ Coinbase string `json:"coinbase"`
+ Block string `json:"block"`
+ Number int32 `json:"number"`
+ Value string `json:"value"`
+}
+
+func NewJSMessage(message *ethstate.Message) JSMessage {
+ return JSMessage{
+ To: ethutil.Bytes2Hex(message.To),
+ From: ethutil.Bytes2Hex(message.From),
+ Input: ethutil.Bytes2Hex(message.Input),
+ Output: ethutil.Bytes2Hex(message.Output),
+ Path: int32(message.Path),
+ Origin: ethutil.Bytes2Hex(message.Origin),
+ Timestamp: int32(message.Timestamp),
+ Coinbase: ethutil.Bytes2Hex(message.Origin),
+ Block: ethutil.Bytes2Hex(message.Block),
+ Number: int32(message.Number.Int64()),
+ Value: message.Value.String(),
+ }
+}
diff --git a/ethpipe/object.go b/ethpipe/object.go
new file mode 100644
index 0000000000000000000000000000000000000000..356ed788c7f11097806a253fa49d17c72bc5cd1d
--- /dev/null
+++ b/ethpipe/object.go
@@ -0,0 +1,26 @@
+package ethpipe
+
+import (
+ "github.com/ethereum/go-ethereum/ethstate"
+ "github.com/ethereum/go-ethereum/ethutil"
+)
+
+type Object struct {
+ *ethstate.StateObject
+}
+
+func (self *Object) StorageString(str string) *ethutil.Value {
+ if ethutil.IsHex(str) {
+ return self.Storage(ethutil.Hex2Bytes(str[2:]))
+ } else {
+ return self.Storage(ethutil.RightPadBytes([]byte(str), 32))
+ }
+}
+
+func (self *Object) StorageValue(addr *ethutil.Value) *ethutil.Value {
+ return self.Storage(addr.Bytes())
+}
+
+func (self *Object) Storage(addr []byte) *ethutil.Value {
+ return self.StateObject.GetStorage(ethutil.BigD(addr))
+}
diff --git a/ethpipe/pipe.go b/ethpipe/pipe.go
new file mode 100644
index 0000000000000000000000000000000000000000..13085c887f7d091b806265666ec18bbfeb057356
--- /dev/null
+++ b/ethpipe/pipe.go
@@ -0,0 +1,171 @@
+package ethpipe
+
+import (
+ "fmt"
+ "strings"
+
+ "github.com/ethereum/go-ethereum/ethchain"
+ "github.com/ethereum/go-ethereum/ethcrypto"
+ "github.com/ethereum/go-ethereum/ethlog"
+ "github.com/ethereum/go-ethereum/ethstate"
+ "github.com/ethereum/go-ethereum/ethutil"
+ "github.com/ethereum/go-ethereum/vm"
+)
+
+var logger = ethlog.NewLogger("PIPE")
+
+type VmVars struct {
+ State *ethstate.State
+}
+
+type Pipe struct {
+ obj ethchain.EthManager
+ stateManager *ethchain.StateManager
+ blockChain *ethchain.ChainManager
+ world *World
+
+ Vm VmVars
+}
+
+func New(obj ethchain.EthManager) *Pipe {
+ pipe := &Pipe{
+ obj: obj,
+ stateManager: obj.StateManager(),
+ blockChain: obj.ChainManager(),
+ }
+ pipe.world = NewWorld(pipe)
+
+ return pipe
+}
+
+func (self *Pipe) Balance(addr []byte) *ethutil.Value {
+ return ethutil.NewValue(self.World().safeGet(addr).Balance)
+}
+
+func (self *Pipe) Nonce(addr []byte) uint64 {
+ return self.World().safeGet(addr).Nonce
+}
+
+func (self *Pipe) Execute(addr []byte, data []byte, value, gas, price *ethutil.Value) ([]byte, error) {
+ return self.ExecuteObject(&Object{self.World().safeGet(addr)}, data, value, gas, price)
+}
+
+func (self *Pipe) ExecuteObject(object *Object, data []byte, value, gas, price *ethutil.Value) ([]byte, error) {
+ var (
+ initiator = ethstate.NewStateObject(self.obj.KeyManager().KeyPair().Address())
+ block = self.blockChain.CurrentBlock
+ )
+
+ self.Vm.State = self.World().State().Copy()
+
+ evm := vm.New(NewEnv(self.Vm.State, block, value.BigInt(), initiator.Address()), vm.Type(ethutil.Config.VmType))
+
+ msg := vm.NewExecution(evm, object.Address(), data, gas.BigInt(), price.BigInt(), value.BigInt())
+ ret, err := msg.Exec(object.Address(), initiator)
+
+ fmt.Println("returned from call", ret, err)
+
+ return ret, err
+}
+
+func (self *Pipe) Block(hash []byte) *ethchain.Block {
+ return self.blockChain.GetBlock(hash)
+}
+
+func (self *Pipe) Storage(addr, storageAddr []byte) *ethutil.Value {
+ return self.World().safeGet(addr).GetStorage(ethutil.BigD(storageAddr))
+}
+
+func (self *Pipe) ToAddress(priv []byte) []byte {
+ pair, err := ethcrypto.NewKeyPairFromSec(priv)
+ if err != nil {
+ return nil
+ }
+
+ return pair.Address()
+}
+
+func (self *Pipe) Exists(addr []byte) bool {
+ return self.World().Get(addr) != nil
+}
+
+func (self *Pipe) TransactString(key *ethcrypto.KeyPair, rec string, value, gas, price *ethutil.Value, data []byte) ([]byte, error) {
+ // Check if an address is stored by this address
+ var hash []byte
+ addr := self.World().Config().Get("NameReg").StorageString(rec).Bytes()
+ if len(addr) > 0 {
+ hash = addr
+ } else if ethutil.IsHex(rec) {
+ hash = ethutil.Hex2Bytes(rec[2:])
+ } else {
+ hash = ethutil.Hex2Bytes(rec)
+ }
+
+ return self.Transact(key, hash, value, gas, price, data)
+}
+
+func (self *Pipe) Transact(key *ethcrypto.KeyPair, rec []byte, value, gas, price *ethutil.Value, data []byte) ([]byte, error) {
+ var hash []byte
+ var contractCreation bool
+ if rec == nil {
+ contractCreation = true
+ }
+
+ var tx *ethchain.Transaction
+ // Compile and assemble the given data
+ if contractCreation {
+ script, err := ethutil.Compile(string(data), false)
+ if err != nil {
+ return nil, err
+ }
+
+ tx = ethchain.NewContractCreationTx(value.BigInt(), gas.BigInt(), price.BigInt(), script)
+ } else {
+ data := ethutil.StringToByteFunc(string(data), func(s string) (ret []byte) {
+ slice := strings.Split(s, "\n")
+ for _, dataItem := range slice {
+ d := ethutil.FormatData(dataItem)
+ ret = append(ret, d...)
+ }
+ return
+ })
+
+ tx = ethchain.NewTransactionMessage(hash, value.BigInt(), gas.BigInt(), price.BigInt(), data)
+ }
+
+ acc := self.stateManager.TransState().GetOrNewStateObject(key.Address())
+ tx.Nonce = acc.Nonce
+ acc.Nonce += 1
+ self.stateManager.TransState().UpdateStateObject(acc)
+
+ tx.Sign(key.PrivateKey)
+ self.obj.TxPool().QueueTransaction(tx)
+
+ if contractCreation {
+ addr := tx.CreationAddress(self.World().State())
+ logger.Infof("Contract addr %x\n", addr)
+
+ return addr, nil
+ }
+
+ return tx.Hash(), nil
+}
+
+func (self *Pipe) PushTx(tx *ethchain.Transaction) ([]byte, error) {
+ self.obj.TxPool().QueueTransaction(tx)
+ if tx.Recipient == nil {
+ addr := tx.CreationAddress(self.World().State())
+ logger.Infof("Contract addr %x\n", addr)
+ return addr, nil
+ }
+ return tx.Hash(), nil
+}
+
+func (self *Pipe) CompileMutan(code string) ([]byte, error) {
+ data, err := ethutil.Compile(code, false)
+ if err != nil {
+ return nil, err
+ }
+
+ return data, nil
+}
diff --git a/ethpipe/pipe_test.go b/ethpipe/pipe_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..3b5dc5e4c47a5222736db311abb590a7e45bd284
--- /dev/null
+++ b/ethpipe/pipe_test.go
@@ -0,0 +1,58 @@
+package ethpipe
+
+import (
+ "testing"
+
+ "github.com/ethereum/go-ethereum/ethcrypto"
+ "github.com/ethereum/go-ethereum/ethstate"
+ "github.com/ethereum/go-ethereum/ethutil"
+)
+
+func Val(v interface{}) *ethutil.Value {
+ return ethutil.NewValue(v)
+}
+
+func TestNew(t *testing.T) {
+ pipe := New(nil)
+
+ var addr, privy, recp, data []byte
+ var object *ethstate.StateObject
+ var key *ethcrypto.KeyPair
+
+ world := pipe.World()
+ world.Get(addr)
+ world.Coinbase()
+ world.IsMining()
+ world.IsListening()
+ world.State()
+ peers := world.Peers()
+ peers.Len()
+
+ // Shortcut functions
+ pipe.Balance(addr)
+ pipe.Nonce(addr)
+ pipe.Block(addr)
+ pipe.Storage(addr, addr)
+ pipe.ToAddress(privy)
+ pipe.Exists(addr)
+ // Doesn't change state
+ pipe.Execute(addr, nil, Val(0), Val(1000000), Val(10))
+ // Doesn't change state
+ pipe.ExecuteObject(object, nil, Val(0), Val(1000000), Val(10))
+
+ conf := world.Config()
+ namereg := conf.Get("NameReg")
+ namereg.Storage(addr)
+
+ var err error
+ // Transact
+ err = pipe.Transact(key, recp, ethutil.NewValue(0), ethutil.NewValue(0), ethutil.NewValue(0), nil)
+ if err != nil {
+ t.Error(err)
+ }
+ // Create
+ err = pipe.Transact(key, nil, ethutil.NewValue(0), ethutil.NewValue(0), ethutil.NewValue(0), data)
+ if err != nil {
+ t.Error(err)
+ }
+}
diff --git a/ethpipe/vm_env.go b/ethpipe/vm_env.go
new file mode 100644
index 0000000000000000000000000000000000000000..140726bfe0dea610bb578a467446b318c8320d02
--- /dev/null
+++ b/ethpipe/vm_env.go
@@ -0,0 +1,39 @@
+package ethpipe
+
+import (
+ "math/big"
+
+ "github.com/ethereum/go-ethereum/ethchain"
+ "github.com/ethereum/go-ethereum/ethstate"
+ "github.com/ethereum/go-ethereum/vm"
+)
+
+type VMEnv struct {
+ state *ethstate.State
+ block *ethchain.Block
+ value *big.Int
+ sender []byte
+}
+
+func NewEnv(state *ethstate.State, block *ethchain.Block, value *big.Int, sender []byte) *VMEnv {
+ return &VMEnv{
+ state: state,
+ block: block,
+ value: value,
+ sender: sender,
+ }
+}
+
+func (self *VMEnv) Origin() []byte { return self.sender }
+func (self *VMEnv) BlockNumber() *big.Int { return self.block.Number }
+func (self *VMEnv) PrevHash() []byte { return self.block.PrevHash }
+func (self *VMEnv) Coinbase() []byte { return self.block.Coinbase }
+func (self *VMEnv) Time() int64 { return self.block.Time }
+func (self *VMEnv) Difficulty() *big.Int { return self.block.Difficulty }
+func (self *VMEnv) BlockHash() []byte { return self.block.Hash() }
+func (self *VMEnv) Value() *big.Int { return self.value }
+func (self *VMEnv) State() *ethstate.State { return self.state }
+func (self *VMEnv) GasLimit() *big.Int { return self.block.GasLimit }
+func (self *VMEnv) Transfer(from, to vm.Account, amount *big.Int) error {
+ return vm.Transfer(from, to, amount)
+}
diff --git a/ethpipe/world.go b/ethpipe/world.go
new file mode 100644
index 0000000000000000000000000000000000000000..e34bd31aa5d52b5e90d73d6d5ac53419316c0f21
--- /dev/null
+++ b/ethpipe/world.go
@@ -0,0 +1,64 @@
+package ethpipe
+
+import (
+ "container/list"
+
+ "github.com/ethereum/go-ethereum/ethstate"
+)
+
+type World struct {
+ pipe *Pipe
+ cfg *Config
+}
+
+func NewWorld(pipe *Pipe) *World {
+ world := &World{pipe, nil}
+ world.cfg = &Config{pipe}
+
+ return world
+}
+
+func (self *Pipe) World() *World {
+ return self.world
+}
+
+func (self *World) State() *ethstate.State {
+ return self.pipe.stateManager.CurrentState()
+}
+
+func (self *World) Get(addr []byte) *Object {
+ return &Object{self.State().GetStateObject(addr)}
+}
+
+func (self *World) SafeGet(addr []byte) *Object {
+ return &Object{self.safeGet(addr)}
+}
+
+func (self *World) safeGet(addr []byte) *ethstate.StateObject {
+ object := self.State().GetStateObject(addr)
+ if object == nil {
+ object = ethstate.NewStateObject(addr)
+ }
+
+ return object
+}
+
+func (self *World) Coinbase() *ethstate.StateObject {
+ return nil
+}
+
+func (self *World) IsMining() bool {
+ return self.pipe.obj.IsMining()
+}
+
+func (self *World) IsListening() bool {
+ return self.pipe.obj.IsListening()
+}
+
+func (self *World) Peers() *list.List {
+ return self.pipe.obj.Peers()
+}
+
+func (self *World) Config() *Config {
+ return self.cfg
+}
diff --git a/ethstate/.ethtest b/ethstate/.ethtest
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/ethstate/dump.go b/ethstate/dump.go
new file mode 100644
index 0000000000000000000000000000000000000000..fd92ac4dfe30ffea55773cfd007c9b2cf59a01df
--- /dev/null
+++ b/ethstate/dump.go
@@ -0,0 +1,47 @@
+package ethstate
+
+import (
+ "encoding/json"
+ "fmt"
+
+ "github.com/ethereum/go-ethereum/ethutil"
+)
+
+type Account struct {
+ Balance string `json:"balance"`
+ Nonce uint64 `json:"nonce"`
+ CodeHash string `json:"codeHash"`
+ Storage map[string]string `json:"storage"`
+}
+
+type World struct {
+ Root string `json:"root"`
+ Accounts map[string]Account `json:"accounts"`
+}
+
+func (self *State) Dump() []byte {
+ world := World{
+ Root: ethutil.Bytes2Hex(self.Trie.Root.([]byte)),
+ Accounts: make(map[string]Account),
+ }
+
+ self.Trie.NewIterator().Each(func(key string, value *ethutil.Value) {
+ stateObject := NewStateObjectFromBytes([]byte(key), value.Bytes())
+
+ account := Account{Balance: stateObject.balance.String(), Nonce: stateObject.Nonce, CodeHash: ethutil.Bytes2Hex(stateObject.codeHash)}
+ account.Storage = make(map[string]string)
+
+ stateObject.EachStorage(func(key string, value *ethutil.Value) {
+ value.Decode()
+ account.Storage[ethutil.Bytes2Hex([]byte(key))] = ethutil.Bytes2Hex(value.Bytes())
+ })
+ world.Accounts[ethutil.Bytes2Hex([]byte(key))] = account
+ })
+
+ json, err := json.MarshalIndent(world, "", " ")
+ if err != nil {
+ fmt.Println("dump err", err)
+ }
+
+ return json
+}
diff --git a/ethstate/errors.go b/ethstate/errors.go
new file mode 100644
index 0000000000000000000000000000000000000000..d5d7db86b482d5f231ff7ffb22921f247de2fef6
--- /dev/null
+++ b/ethstate/errors.go
@@ -0,0 +1,23 @@
+package ethstate
+
+import (
+ "fmt"
+ "math/big"
+)
+
+type GasLimitErr struct {
+ Message string
+ Is, Max *big.Int
+}
+
+func IsGasLimitErr(err error) bool {
+ _, ok := err.(*GasLimitErr)
+
+ return ok
+}
+func (err *GasLimitErr) Error() string {
+ return err.Message
+}
+func GasLimitError(is, max *big.Int) *GasLimitErr {
+ return &GasLimitErr{Message: fmt.Sprintf("GasLimit error. Max %s, transaction would take it to %s", max, is), Is: is, Max: max}
+}
diff --git a/ethstate/manifest.go b/ethstate/manifest.go
new file mode 100644
index 0000000000000000000000000000000000000000..945de22abc97147cc0ba6a1e6bcc392187c9e615
--- /dev/null
+++ b/ethstate/manifest.go
@@ -0,0 +1,55 @@
+package ethstate
+
+import (
+ "fmt"
+ "math/big"
+)
+
+// Object manifest
+//
+// The object manifest is used to keep changes to the state so we can keep track of the changes
+// that occurred during a state transitioning phase.
+type Manifest struct {
+ Messages Messages
+}
+
+func NewManifest() *Manifest {
+ m := &Manifest{}
+ m.Reset()
+
+ return m
+}
+
+func (m *Manifest) Reset() {
+ m.Messages = nil
+}
+
+func (self *Manifest) AddMessage(msg *Message) *Message {
+ self.Messages = append(self.Messages, msg)
+
+ return msg
+}
+
+type Messages []*Message
+type Message struct {
+ To, From []byte
+ Input []byte
+ Output []byte
+ Path int
+ Origin []byte
+ Timestamp int64
+ Coinbase []byte
+ Block []byte
+ Number *big.Int
+ Value *big.Int
+
+ ChangedAddresses [][]byte
+}
+
+func (self *Message) AddStorageChange(addr []byte) {
+ self.ChangedAddresses = append(self.ChangedAddresses, addr)
+}
+
+func (self *Message) String() string {
+ return fmt.Sprintf("Message{to: %x from: %x input: %x output: %x origin: %x coinbase: %x block: %x number: %v timestamp: %d path: %d value: %v", self.To, self.From, self.Input, self.Output, self.Origin, self.Coinbase, self.Block, self.Number, self.Timestamp, self.Path, self.Value)
+}
diff --git a/ethstate/state.go b/ethstate/state.go
new file mode 100644
index 0000000000000000000000000000000000000000..fd6fa65a5a72385bfbc9a5399255636882703c16
--- /dev/null
+++ b/ethstate/state.go
@@ -0,0 +1,271 @@
+package ethstate
+
+import (
+ "math/big"
+
+ "github.com/ethereum/go-ethereum/ethlog"
+ "github.com/ethereum/go-ethereum/ethtrie"
+ "github.com/ethereum/go-ethereum/ethutil"
+)
+
+var statelogger = ethlog.NewLogger("STATE")
+
+// States within the ethereum protocol are used to store anything
+// within the merkle trie. States take care of caching and storing
+// nested states. It's the general query interface to retrieve:
+// * Contracts
+// * Accounts
+type State struct {
+ // The trie for this structure
+ Trie *ethtrie.Trie
+
+ stateObjects map[string]*StateObject
+
+ manifest *Manifest
+}
+
+// Create a new state from a given trie
+func New(trie *ethtrie.Trie) *State {
+ return &State{Trie: trie, stateObjects: make(map[string]*StateObject), manifest: NewManifest()}
+}
+
+// Retrieve the balance from the given address or 0 if object not found
+func (self *State) GetBalance(addr []byte) *big.Int {
+ stateObject := self.GetStateObject(addr)
+ if stateObject != nil {
+ return stateObject.balance
+ }
+
+ return ethutil.Big0
+}
+
+func (self *State) GetNonce(addr []byte) uint64 {
+ stateObject := self.GetStateObject(addr)
+ if stateObject != nil {
+ return stateObject.Nonce
+ }
+
+ return 0
+}
+
+func (self *State) SetNonce(addr []byte, nonce uint64) {
+ stateObject := self.GetStateObject(addr)
+ if stateObject != nil {
+ stateObject.Nonce = nonce
+ }
+}
+
+func (self *State) GetCode(addr []byte) []byte {
+ stateObject := self.GetStateObject(addr)
+ if stateObject != nil {
+ return stateObject.Code
+ }
+
+ return nil
+}
+
+func (self *State) GetState(a, b []byte) []byte {
+ stateObject := self.GetStateObject(a)
+ if stateObject != nil {
+ return stateObject.GetState(b).Bytes()
+ }
+
+ return nil
+}
+
+func (self *State) SetState(addr, key []byte, value interface{}) {
+ stateObject := self.GetStateObject(addr)
+ if stateObject != nil {
+ stateObject.SetState(key, ethutil.NewValue(value))
+ }
+}
+
+func (self *State) Delete(addr []byte) bool {
+ stateObject := self.GetStateObject(addr)
+ if stateObject != nil {
+ stateObject.MarkForDeletion()
+
+ return true
+ }
+
+ return false
+}
+
+//
+// Setting, updating & deleting state object methods
+//
+
+// Update the given state object and apply it to state trie
+func (self *State) UpdateStateObject(stateObject *StateObject) {
+ addr := stateObject.Address()
+
+ if len(stateObject.CodeHash()) > 0 {
+ ethutil.Config.Db.Put(stateObject.CodeHash(), stateObject.Code)
+ }
+
+ self.Trie.Update(string(addr), string(stateObject.RlpEncode()))
+}
+
+// Delete the given state object and delete it from the state trie
+func (self *State) DeleteStateObject(stateObject *StateObject) {
+ self.Trie.Delete(string(stateObject.Address()))
+
+ delete(self.stateObjects, string(stateObject.Address()))
+}
+
+// Retrieve a state object given my the address. Nil if not found
+func (self *State) GetStateObject(addr []byte) *StateObject {
+ addr = ethutil.Address(addr)
+
+ stateObject := self.stateObjects[string(addr)]
+ if stateObject != nil {
+ return stateObject
+ }
+
+ data := self.Trie.Get(string(addr))
+ if len(data) == 0 {
+ return nil
+ }
+
+ stateObject = NewStateObjectFromBytes(addr, []byte(data))
+ self.SetStateObject(stateObject)
+
+ return stateObject
+}
+
+func (self *State) SetStateObject(object *StateObject) {
+ self.stateObjects[string(object.address)] = object
+}
+
+// Retrieve a state object or create a new state object if nil
+func (self *State) GetOrNewStateObject(addr []byte) *StateObject {
+ stateObject := self.GetStateObject(addr)
+ if stateObject == nil {
+ stateObject = self.NewStateObject(addr)
+ }
+
+ return stateObject
+}
+
+// Create a state object whether it exist in the trie or not
+func (self *State) NewStateObject(addr []byte) *StateObject {
+ addr = ethutil.Address(addr)
+
+ statelogger.Debugf("(+) %x\n", addr)
+
+ stateObject := NewStateObject(addr)
+ self.stateObjects[string(addr)] = stateObject
+
+ return stateObject
+}
+
+// Deprecated
+func (self *State) GetAccount(addr []byte) *StateObject {
+ return self.GetOrNewStateObject(addr)
+}
+
+//
+// Setting, copying of the state methods
+//
+
+func (s *State) Cmp(other *State) bool {
+ return s.Trie.Cmp(other.Trie)
+}
+
+func (self *State) Copy() *State {
+ if self.Trie != nil {
+ state := New(self.Trie.Copy())
+ for k, stateObject := range self.stateObjects {
+ state.stateObjects[k] = stateObject.Copy()
+ }
+
+ return state
+ }
+
+ return nil
+}
+
+func (self *State) Set(state *State) {
+ if state == nil {
+ panic("Tried setting 'state' to nil through 'Set'")
+ }
+
+ self.Trie = state.Trie
+ self.stateObjects = state.stateObjects
+}
+
+func (s *State) Root() interface{} {
+ return s.Trie.Root
+}
+
+// Resets the trie and all siblings
+func (s *State) Reset() {
+ s.Trie.Undo()
+
+ // Reset all nested states
+ for _, stateObject := range s.stateObjects {
+ if stateObject.State == nil {
+ continue
+ }
+
+ //stateObject.state.Reset()
+ stateObject.Reset()
+ }
+
+ s.Empty()
+}
+
+// Syncs the trie and all siblings
+func (s *State) Sync() {
+ // Sync all nested states
+ for _, stateObject := range s.stateObjects {
+ if stateObject.State == nil {
+ continue
+ }
+
+ stateObject.State.Sync()
+ }
+
+ s.Trie.Sync()
+
+ s.Empty()
+}
+
+func (self *State) Empty() {
+ self.stateObjects = make(map[string]*StateObject)
+}
+
+func (self *State) Update() {
+ var deleted bool
+ for _, stateObject := range self.stateObjects {
+ if stateObject.remove {
+ self.DeleteStateObject(stateObject)
+ deleted = true
+ } else {
+ stateObject.Sync()
+
+ self.UpdateStateObject(stateObject)
+ }
+ }
+
+ // FIXME trie delete is broken
+ if deleted {
+ valid, t2 := ethtrie.ParanoiaCheck(self.Trie)
+ if !valid {
+ statelogger.Infof("Warn: PARANOIA: Different state root during copy %x vs %x\n", self.Trie.Root, t2.Root)
+
+ self.Trie = t2
+ }
+ }
+}
+
+func (self *State) Manifest() *Manifest {
+ return self.manifest
+}
+
+// Debug stuff
+func (self *State) CreateOutputForDiff() {
+ for _, stateObject := range self.stateObjects {
+ stateObject.CreateOutputForDiff()
+ }
+}
diff --git a/ethstate/state_object.go b/ethstate/state_object.go
new file mode 100644
index 0000000000000000000000000000000000000000..d8aba995083345617b9175a0171bcc2e82f41dfa
--- /dev/null
+++ b/ethstate/state_object.go
@@ -0,0 +1,339 @@
+package ethstate
+
+import (
+ "fmt"
+ "math/big"
+
+ "github.com/ethereum/go-ethereum/ethcrypto"
+ "github.com/ethereum/go-ethereum/ethtrie"
+ "github.com/ethereum/go-ethereum/ethutil"
+)
+
+type Code []byte
+
+func (self Code) String() string {
+ return string(self) //strings.Join(Disassemble(self), " ")
+}
+
+type Storage map[string]*ethutil.Value
+
+func (self Storage) Copy() Storage {
+ cpy := make(Storage)
+ for key, value := range self {
+ // XXX Do we need a 'value' copy or is this sufficient?
+ cpy[key] = value
+ }
+
+ return cpy
+}
+
+type StateObject struct {
+ // Address of the object
+ address []byte
+ // Shared attributes
+ balance *big.Int
+ codeHash []byte
+ Nonce uint64
+ // Contract related attributes
+ State *State
+ Code Code
+ InitCode Code
+
+ storage Storage
+
+ // Total gas pool is the total amount of gas currently
+ // left if this object is the coinbase. Gas is directly
+ // purchased of the coinbase.
+ gasPool *big.Int
+
+ // Mark for deletion
+ // When an object is marked for deletion it will be delete from the trie
+ // during the "update" phase of the state transition
+ remove bool
+}
+
+func (self *StateObject) Reset() {
+ self.storage = make(Storage)
+ self.State.Reset()
+}
+
+func NewStateObject(addr []byte) *StateObject {
+ // This to ensure that it has 20 bytes (and not 0 bytes), thus left or right pad doesn't matter.
+ address := ethutil.Address(addr)
+
+ object := &StateObject{address: address, balance: new(big.Int), gasPool: new(big.Int)}
+ object.State = New(ethtrie.New(ethutil.Config.Db, ""))
+ object.storage = make(Storage)
+ object.gasPool = new(big.Int)
+
+ return object
+}
+
+func NewContract(address []byte, balance *big.Int, root []byte) *StateObject {
+ contract := NewStateObject(address)
+ contract.balance = balance
+ contract.State = New(ethtrie.New(ethutil.Config.Db, string(root)))
+
+ return contract
+}
+
+func NewStateObjectFromBytes(address, data []byte) *StateObject {
+ object := &StateObject{address: address}
+ object.RlpDecode(data)
+
+ return object
+}
+
+func (self *StateObject) MarkForDeletion() {
+ self.remove = true
+ statelogger.DebugDetailf("%x: #%d %v (deletion)\n", self.Address(), self.Nonce, self.balance)
+}
+
+func (c *StateObject) GetAddr(addr []byte) *ethutil.Value {
+ return ethutil.NewValueFromBytes([]byte(c.State.Trie.Get(string(addr))))
+}
+
+func (c *StateObject) SetAddr(addr []byte, value interface{}) {
+ c.State.Trie.Update(string(addr), string(ethutil.NewValue(value).Encode()))
+}
+
+func (self *StateObject) GetStorage(key *big.Int) *ethutil.Value {
+ return self.GetState(key.Bytes())
+}
+func (self *StateObject) SetStorage(key *big.Int, value *ethutil.Value) {
+ self.SetState(key.Bytes(), value)
+}
+
+func (self *StateObject) Storage() map[string]*ethutil.Value {
+ return self.storage
+}
+
+func (self *StateObject) GetState(k []byte) *ethutil.Value {
+ key := ethutil.LeftPadBytes(k, 32)
+
+ value := self.storage[string(key)]
+ if value == nil {
+ value = self.GetAddr(key)
+
+ if !value.IsNil() {
+ self.storage[string(key)] = value
+ }
+ }
+
+ return value
+}
+
+func (self *StateObject) SetState(k []byte, value *ethutil.Value) {
+ key := ethutil.LeftPadBytes(k, 32)
+ self.storage[string(key)] = value.Copy()
+}
+
+// Iterate over each storage address and yield callback
+func (self *StateObject) EachStorage(cb ethtrie.EachCallback) {
+ // First loop over the uncommit/cached values in storage
+ for key, value := range self.storage {
+ // XXX Most iterators Fns as it stands require encoded values
+ encoded := ethutil.NewValue(value.Encode())
+ cb(key, encoded)
+ }
+
+ it := self.State.Trie.NewIterator()
+ it.Each(func(key string, value *ethutil.Value) {
+ // If it's cached don't call the callback.
+ if self.storage[key] == nil {
+ cb(key, value)
+ }
+ })
+}
+
+func (self *StateObject) Sync() {
+ for key, value := range self.storage {
+ if value.Len() == 0 { // value.BigInt().Cmp(ethutil.Big0) == 0 {
+ //data := self.getStorage([]byte(key))
+ //fmt.Printf("deleting %x %x 0x%x\n", self.Address(), []byte(key), data)
+ self.State.Trie.Delete(string(key))
+ continue
+ }
+
+ self.SetAddr([]byte(key), value)
+ }
+
+ valid, t2 := ethtrie.ParanoiaCheck(self.State.Trie)
+ if !valid {
+ statelogger.Infof("Warn: PARANOIA: Different state storage root during copy %x vs %x\n", self.State.Trie.Root, t2.Root)
+
+ self.State.Trie = t2
+ }
+}
+
+func (c *StateObject) GetInstr(pc *big.Int) *ethutil.Value {
+ if int64(len(c.Code)-1) < pc.Int64() {
+ return ethutil.NewValue(0)
+ }
+
+ return ethutil.NewValueFromBytes([]byte{c.Code[pc.Int64()]})
+}
+
+func (c *StateObject) AddBalance(amount *big.Int) {
+ c.SetBalance(new(big.Int).Add(c.balance, amount))
+
+ statelogger.Debugf("%x: #%d %v (+ %v)\n", c.Address(), c.Nonce, c.balance, amount)
+}
+func (c *StateObject) AddAmount(amount *big.Int) { c.AddBalance(amount) }
+
+func (c *StateObject) SubBalance(amount *big.Int) {
+ c.SetBalance(new(big.Int).Sub(c.balance, amount))
+
+ statelogger.Debugf("%x: #%d %v (- %v)\n", c.Address(), c.Nonce, c.balance, amount)
+}
+func (c *StateObject) SubAmount(amount *big.Int) { c.SubBalance(amount) }
+
+func (c *StateObject) SetBalance(amount *big.Int) {
+ c.balance = amount
+}
+
+func (self *StateObject) Balance() *big.Int { return self.balance }
+
+//
+// Gas setters and getters
+//
+
+// Return the gas back to the origin. Used by the Virtual machine or Closures
+func (c *StateObject) ReturnGas(gas, price *big.Int) {}
+func (c *StateObject) ConvertGas(gas, price *big.Int) error {
+ total := new(big.Int).Mul(gas, price)
+ if total.Cmp(c.balance) > 0 {
+ return fmt.Errorf("insufficient amount: %v, %v", c.balance, total)
+ }
+
+ c.SubAmount(total)
+
+ return nil
+}
+
+func (self *StateObject) SetGasPool(gasLimit *big.Int) {
+ self.gasPool = new(big.Int).Set(gasLimit)
+
+ statelogger.DebugDetailf("%x: fuel (+ %v)", self.Address(), self.gasPool)
+}
+
+func (self *StateObject) BuyGas(gas, price *big.Int) error {
+ if self.gasPool.Cmp(gas) < 0 {
+ return GasLimitError(self.gasPool, gas)
+ }
+
+ rGas := new(big.Int).Set(gas)
+ rGas.Mul(rGas, price)
+
+ self.AddAmount(rGas)
+
+ return nil
+}
+
+func (self *StateObject) RefundGas(gas, price *big.Int) {
+ self.gasPool.Add(self.gasPool, gas)
+
+ rGas := new(big.Int).Set(gas)
+ rGas.Mul(rGas, price)
+
+ self.balance.Sub(self.balance, rGas)
+}
+
+func (self *StateObject) Copy() *StateObject {
+ stateObject := NewStateObject(self.Address())
+ stateObject.balance.Set(self.balance)
+ stateObject.codeHash = ethutil.CopyBytes(self.codeHash)
+ stateObject.Nonce = self.Nonce
+ if self.State != nil {
+ stateObject.State = self.State.Copy()
+ }
+ stateObject.Code = ethutil.CopyBytes(self.Code)
+ stateObject.InitCode = ethutil.CopyBytes(self.InitCode)
+ stateObject.storage = self.storage.Copy()
+ stateObject.gasPool.Set(self.gasPool)
+ stateObject.remove = self.remove
+
+ return stateObject
+}
+
+func (self *StateObject) Set(stateObject *StateObject) {
+ *self = *stateObject
+}
+
+//
+// Attribute accessors
+//
+
+func (c *StateObject) N() *big.Int {
+ return big.NewInt(int64(c.Nonce))
+}
+
+// Returns the address of the contract/account
+func (c *StateObject) Address() []byte {
+ return c.address
+}
+
+// Returns the initialization Code
+func (c *StateObject) Init() Code {
+ return c.InitCode
+}
+
+// To satisfy ClosureRef
+func (self *StateObject) Object() *StateObject {
+ return self
+}
+
+// Debug stuff
+func (self *StateObject) CreateOutputForDiff() {
+ fmt.Printf("%x %x %x %x\n", self.Address(), self.State.Root(), self.balance.Bytes(), self.Nonce)
+ self.EachStorage(func(addr string, value *ethutil.Value) {
+ fmt.Printf("%x %x\n", addr, value.Bytes())
+ })
+}
+
+//
+// Encoding
+//
+
+// State object encoding methods
+func (c *StateObject) RlpEncode() []byte {
+ var root interface{}
+ if c.State != nil {
+ root = c.State.Trie.Root
+ } else {
+ root = ""
+ }
+
+ return ethutil.Encode([]interface{}{c.Nonce, c.balance, root, c.CodeHash()})
+}
+
+func (c *StateObject) CodeHash() ethutil.Bytes {
+ var codeHash []byte
+ if len(c.Code) > 0 {
+ codeHash = ethcrypto.Sha3(c.Code)
+ }
+
+ return codeHash
+}
+
+func (c *StateObject) RlpDecode(data []byte) {
+ decoder := ethutil.NewValueFromBytes(data)
+
+ c.Nonce = decoder.Get(0).Uint()
+ c.balance = decoder.Get(1).BigInt()
+ c.State = New(ethtrie.New(ethutil.Config.Db, decoder.Get(2).Interface()))
+ c.storage = make(map[string]*ethutil.Value)
+ c.gasPool = new(big.Int)
+
+ c.codeHash = decoder.Get(3).Bytes()
+
+ c.Code, _ = ethutil.Config.Db.Get(c.codeHash)
+}
+
+// Storage change object. Used by the manifest for notifying changes to
+// the sub channels.
+type StorageState struct {
+ StateAddress []byte
+ Address []byte
+ Value *big.Int
+}
diff --git a/ethstate/state_test.go b/ethstate/state_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..2454fce84c83828e62e59a25d944d6f3a98ab569
--- /dev/null
+++ b/ethstate/state_test.go
@@ -0,0 +1,36 @@
+package ethstate
+
+import (
+ "testing"
+
+ "github.com/ethereum/go-ethereum/ethdb"
+ "github.com/ethereum/go-ethereum/ethtrie"
+ "github.com/ethereum/go-ethereum/ethutil"
+)
+
+var ZeroHash256 = make([]byte, 32)
+
+func TestSnapshot(t *testing.T) {
+ db, _ := ethdb.NewMemDatabase()
+ ethutil.ReadConfig(".ethtest", "/tmp/ethtest", "")
+ ethutil.Config.Db = db
+
+ state := New(ethtrie.New(db, ""))
+
+ stateObject := state.GetOrNewStateObject([]byte("aa"))
+
+ stateObject.SetStorage(ethutil.Big("0"), ethutil.NewValue(42))
+
+ snapshot := state.Copy()
+
+ stateObject = state.GetStateObject([]byte("aa"))
+ stateObject.SetStorage(ethutil.Big("0"), ethutil.NewValue(43))
+
+ state.Set(snapshot)
+
+ stateObject = state.GetStateObject([]byte("aa"))
+ res := stateObject.GetStorage(ethutil.Big("0"))
+ if !res.Cmp(ethutil.NewValue(42)) {
+ t.Error("Expected storage 0 to be 42", res)
+ }
+}
diff --git a/ethtrie/encoding.go b/ethtrie/encoding.go
new file mode 100644
index 0000000000000000000000000000000000000000..bcf2c56691f16d6d4a54c59e1a85c7de159a881a
--- /dev/null
+++ b/ethtrie/encoding.go
@@ -0,0 +1,76 @@
+package ethtrie
+
+import (
+ "bytes"
+ "encoding/hex"
+ "strings"
+)
+
+func CompactEncode(hexSlice []byte) string {
+ terminator := 0
+ if hexSlice[len(hexSlice)-1] == 16 {
+ terminator = 1
+ }
+
+ if terminator == 1 {
+ hexSlice = hexSlice[:len(hexSlice)-1]
+ }
+
+ oddlen := len(hexSlice) % 2
+ flags := byte(2*terminator + oddlen)
+ if oddlen != 0 {
+ hexSlice = append([]byte{flags}, hexSlice...)
+ } else {
+ hexSlice = append([]byte{flags, 0}, hexSlice...)
+ }
+
+ var buff bytes.Buffer
+ for i := 0; i < len(hexSlice); i += 2 {
+ buff.WriteByte(byte(16*hexSlice[i] + hexSlice[i+1]))
+ }
+
+ return buff.String()
+}
+
+func CompactDecode(str string) []byte {
+ base := CompactHexDecode(str)
+ base = base[:len(base)-1]
+ if base[0] >= 2 {
+ base = append(base, 16)
+ }
+ if base[0]%2 == 1 {
+ base = base[1:]
+ } else {
+ base = base[2:]
+ }
+
+ return base
+}
+
+func CompactHexDecode(str string) []byte {
+ base := "0123456789abcdef"
+ hexSlice := make([]byte, 0)
+
+ enc := hex.EncodeToString([]byte(str))
+ for _, v := range enc {
+ hexSlice = append(hexSlice, byte(strings.IndexByte(base, byte(v))))
+ }
+ hexSlice = append(hexSlice, 16)
+
+ return hexSlice
+}
+
+func DecodeCompact(key []byte) string {
+ base := "0123456789abcdef"
+ var str string
+
+ for _, v := range key {
+ if v < 16 {
+ str += string(base[v])
+ }
+ }
+
+ res, _ := hex.DecodeString(str)
+
+ return string(res)
+}
diff --git a/ethtrie/encoding_test.go b/ethtrie/encoding_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..0cceef792ffa425b3255d9273c2e7052d68b5e0f
--- /dev/null
+++ b/ethtrie/encoding_test.go
@@ -0,0 +1,68 @@
+package ethtrie
+
+import (
+ "bytes"
+ "fmt"
+ "testing"
+)
+
+func TestCompactEncode(t *testing.T) {
+ test1 := []byte{1, 2, 3, 4, 5}
+ if res := CompactEncode(test1); res != "\x11\x23\x45" {
+ t.Error(fmt.Sprintf("even compact encode failed. Got: %q", res))
+ }
+
+ test2 := []byte{0, 1, 2, 3, 4, 5}
+ if res := CompactEncode(test2); res != "\x00\x01\x23\x45" {
+ t.Error(fmt.Sprintf("odd compact encode failed. Got: %q", res))
+ }
+
+ test3 := []byte{0, 15, 1, 12, 11, 8 /*term*/, 16}
+ if res := CompactEncode(test3); res != "\x20\x0f\x1c\xb8" {
+ t.Error(fmt.Sprintf("odd terminated compact encode failed. Got: %q", res))
+ }
+
+ test4 := []byte{15, 1, 12, 11, 8 /*term*/, 16}
+ if res := CompactEncode(test4); res != "\x3f\x1c\xb8" {
+ t.Error(fmt.Sprintf("even terminated compact encode failed. Got: %q", res))
+ }
+}
+
+func TestCompactHexDecode(t *testing.T) {
+ exp := []byte{7, 6, 6, 5, 7, 2, 6, 2, 16}
+ res := CompactHexDecode("verb")
+
+ if !bytes.Equal(res, exp) {
+ t.Error("Error compact hex decode. Expected", exp, "got", res)
+ }
+}
+
+func TestCompactDecode(t *testing.T) {
+ exp := []byte{1, 2, 3, 4, 5}
+ res := CompactDecode("\x11\x23\x45")
+
+ if !bytes.Equal(res, exp) {
+ t.Error("odd compact decode. Expected", exp, "got", res)
+ }
+
+ exp = []byte{0, 1, 2, 3, 4, 5}
+ res = CompactDecode("\x00\x01\x23\x45")
+
+ if !bytes.Equal(res, exp) {
+ t.Error("even compact decode. Expected", exp, "got", res)
+ }
+
+ exp = []byte{0, 15, 1, 12, 11, 8 /*term*/, 16}
+ res = CompactDecode("\x20\x0f\x1c\xb8")
+
+ if !bytes.Equal(res, exp) {
+ t.Error("even terminated compact decode. Expected", exp, "got", res)
+ }
+
+ exp = []byte{15, 1, 12, 11, 8 /*term*/, 16}
+ res = CompactDecode("\x3f\x1c\xb8")
+
+ if !bytes.Equal(res, exp) {
+ t.Error("even terminated compact decode. Expected", exp, "got", res)
+ }
+}
diff --git a/ethtrie/iterator.go b/ethtrie/iterator.go
new file mode 100644
index 0000000000000000000000000000000000000000..43f49741607a93a1182794577a47a32a0f7ef1ac
--- /dev/null
+++ b/ethtrie/iterator.go
@@ -0,0 +1,143 @@
+package ethtrie
+
+import (
+ "bytes"
+
+ "github.com/ethereum/go-ethereum/ethutil"
+)
+
+type NodeType byte
+
+const (
+ EmptyNode NodeType = iota
+ BranchNode
+ LeafNode
+ ExtNode
+)
+
+func getType(node *ethutil.Value) NodeType {
+ if node.Len() == 0 {
+ return EmptyNode
+ }
+
+ if node.Len() == 2 {
+ k := CompactDecode(node.Get(0).Str())
+ if HasTerm(k) {
+ return LeafNode
+ }
+
+ return ExtNode
+ }
+
+ return BranchNode
+}
+
+type Iterator struct {
+ Path [][]byte
+ trie *Trie
+
+ Key []byte
+ Value *ethutil.Value
+}
+
+func NewIterator(trie *Trie) *Iterator {
+ return &Iterator{trie: trie}
+}
+
+func (self *Iterator) key(node *ethutil.Value, path [][]byte) []byte {
+ switch getType(node) {
+ case LeafNode:
+ k := RemTerm(CompactDecode(node.Get(0).Str()))
+
+ self.Path = append(path, k)
+ self.Value = node.Get(1)
+
+ return k
+ case BranchNode:
+ if node.Get(16).Len() > 0 {
+ return []byte{16}
+ }
+
+ for i := byte(0); i < 16; i++ {
+ o := self.key(self.trie.getNode(node.Get(int(i)).Raw()), append(path, []byte{i}))
+ if o != nil {
+ return append([]byte{i}, o...)
+ }
+ }
+ case ExtNode:
+ currKey := node.Get(0).Bytes()
+
+ return self.key(self.trie.getNode(node.Get(1).Raw()), append(path, currKey))
+ }
+
+ return nil
+}
+
+func (self *Iterator) next(node *ethutil.Value, key []byte, path [][]byte) []byte {
+ switch typ := getType(node); typ {
+ case EmptyNode:
+ return nil
+ case BranchNode:
+ if len(key) > 0 {
+ subNode := self.trie.getNode(node.Get(int(key[0])).Raw())
+
+ o := self.next(subNode, key[1:], append(path, key[:1]))
+ if o != nil {
+ return append([]byte{key[0]}, o...)
+ }
+ }
+
+ var r byte = 0
+ if len(key) > 0 {
+ r = key[0] + 1
+ }
+
+ for i := r; i < 16; i++ {
+ subNode := self.trie.getNode(node.Get(int(i)).Raw())
+ o := self.key(subNode, append(path, []byte{i}))
+ if o != nil {
+ return append([]byte{i}, o...)
+ }
+ }
+ case LeafNode, ExtNode:
+ k := RemTerm(CompactDecode(node.Get(0).Str()))
+ if typ == LeafNode {
+ if bytes.Compare([]byte(k), []byte(key)) > 0 {
+ self.Value = node.Get(1)
+ self.Path = append(path, k)
+
+ return k
+ }
+ } else {
+ subNode := self.trie.getNode(node.Get(1).Raw())
+ subKey := key[len(k):]
+ var ret []byte
+ if BeginsWith(key, k) {
+ ret = self.next(subNode, subKey, append(path, k))
+ } else if bytes.Compare(k, key[:len(k)]) > 0 {
+ ret = self.key(node, append(path, k))
+ } else {
+ ret = nil
+ }
+
+ if ret != nil {
+ return append(k, ret...)
+ }
+ }
+ }
+
+ return nil
+}
+
+// Get the next in keys
+func (self *Iterator) Next(key string) []byte {
+ self.trie.mut.Lock()
+ defer self.trie.mut.Unlock()
+
+ k := RemTerm(CompactHexDecode(key))
+ n := self.next(self.trie.getNode(self.trie.Root), k, nil)
+
+ self.Key = []byte(DecodeCompact(n))
+
+ return self.Key
+}
diff --git a/ethtrie/slice.go b/ethtrie/slice.go
new file mode 100644
index 0000000000000000000000000000000000000000..f0edc95323c8875f4221e835b55de32bc2320c19
--- /dev/null
+++ b/ethtrie/slice.go
@@ -0,0 +1,53 @@
+package ethtrie
+
+import (
+ "bytes"
+ "math"
+)
+
+// Helper function for comparing slices
+func CompareIntSlice(a, b []int) bool {
+ if len(a) != len(b) {
+ return false
+ }
+ for i, v := range a {
+ if v != b[i] {
+ return false
+ }
+ }
+ return true
+}
+
+// Returns the amount of nibbles that match each other from 0 ...
+func MatchingNibbleLength(a, b []byte) int {
+ var i, length = 0, int(math.Min(float64(len(a)), float64(len(b))))
+
+ for i < length {
+ if a[i] != b[i] {
+ break
+ }
+ i++
+ }
+
+ return i
+}
+
+func HasTerm(s []byte) bool {
+ return s[len(s)-1] == 16
+}
+
+func RemTerm(s []byte) []byte {
+ if HasTerm(s) {
+ return s[:len(s)-1]
+ }
+
+ return s
+}
+
+func BeginsWith(a, b []byte) bool {
+ if len(b) > len(a) {
+ return false
+ }
+
+ return bytes.Equal(a[:len(b)], b)
+}
diff --git a/ethtrie/trie.go b/ethtrie/trie.go
new file mode 100644
index 0000000000000000000000000000000000000000..7a86e79bd3e573a86278eb36819c5faf410aaf25
--- /dev/null
+++ b/ethtrie/trie.go
@@ -0,0 +1,609 @@
+package ethtrie
+
+import (
+ "bytes"
+ "fmt"
+ _ "reflect"
+ "sync"
+
+ "github.com/ethereum/go-ethereum/ethcrypto"
+ "github.com/ethereum/go-ethereum/ethutil"
+)
+
+func __ignore() { fmt.Println("") }
+
+func ParanoiaCheck(t1 *Trie) (bool, *Trie) {
+ t2 := New(ethutil.Config.Db, "")
+
+ t1.NewIterator().Each(func(key string, v *ethutil.Value) {
+ t2.Update(key, v.Str())
+ })
+
+ a := ethutil.NewValue(t2.Root).Bytes()
+ b := ethutil.NewValue(t1.Root).Bytes()
+
+ return bytes.Compare(a, b) == 0, t2
+}
+
+func (s *Cache) Len() int {
+ return len(s.nodes)
+}
+
+// TODO
+// A StateObject is an object that has a state root
+// This is goig to be the object for the second level caching (the caching of object which have a state such as contracts)
+type StateObject interface {
+ State() *Trie
+ Sync()
+ Undo()
+}
+
+type Node struct {
+ Key []byte
+ Value *ethutil.Value
+ Dirty bool
+}
+
+func NewNode(key []byte, val *ethutil.Value, dirty bool) *Node {
+ return &Node{Key: key, Value: val, Dirty: dirty}
+}
+
+func (n *Node) Copy() *Node {
+ return NewNode(n.Key, n.Value, n.Dirty)
+}
+
+type Cache struct {
+ nodes map[string]*Node
+ db ethutil.Database
+ IsDirty bool
+}
+
+func NewCache(db ethutil.Database) *Cache {
+ return &Cache{db: db, nodes: make(map[string]*Node)}
+}
+
+func (cache *Cache) PutValue(v interface{}, force bool) interface{} {
+ value := ethutil.NewValue(v)
+
+ enc := value.Encode()
+ if len(enc) >= 32 || force {
+ sha := ethcrypto.Sha3(enc)
+
+ cache.nodes[string(sha)] = NewNode(sha, value, true)
+ cache.IsDirty = true
+
+ return sha
+ }
+
+ return v
+}
+
+func (cache *Cache) Put(v interface{}) interface{} {
+ return cache.PutValue(v, false)
+}
+
+func (cache *Cache) Get(key []byte) *ethutil.Value {
+ // First check if the key is the cache
+ if cache.nodes[string(key)] != nil {
+ return cache.nodes[string(key)].Value
+ }
+
+ // Get the key of the database instead and cache it
+ data, _ := cache.db.Get(key)
+ // Create the cached value
+ value := ethutil.NewValueFromBytes(data)
+
+ defer func() {
+ if r := recover(); r != nil {
+ fmt.Println("RECOVER GET", cache, cache.nodes)
+ panic("bye")
+ }
+ }()
+ // Create caching node
+ cache.nodes[string(key)] = NewNode(key, value, false)
+
+ return value
+}
+
+func (cache *Cache) Delete(key []byte) {
+ delete(cache.nodes, string(key))
+
+ cache.db.Delete(key)
+}
+
+func (cache *Cache) Commit() {
+ // Don't try to commit if it isn't dirty
+ if !cache.IsDirty {
+ return
+ }
+
+ for key, node := range cache.nodes {
+ if node.Dirty {
+ cache.db.Put([]byte(key), node.Value.Encode())
+ node.Dirty = false
+ }
+ }
+ cache.IsDirty = false
+
+ // If the nodes grows beyond the 200 entries we simple empty it
+ // FIXME come up with something better
+ if len(cache.nodes) > 200 {
+ cache.nodes = make(map[string]*Node)
+ }
+}
+
+func (cache *Cache) Undo() {
+ for key, node := range cache.nodes {
+ if node.Dirty {
+ delete(cache.nodes, key)
+ }
+ }
+ cache.IsDirty = false
+}
+
+// A (modified) Radix Trie implementation. The Trie implements
+// a caching mechanism and will used cached values if they are
+// present. If a node is not present in the cache it will try to
+// fetch it from the database and store the cached value.
+// Please note that the data isn't persisted unless `Sync` is
+// explicitly called.
+type Trie struct {
+ mut sync.RWMutex
+ prevRoot interface{}
+ Root interface{}
+ //db Database
+ cache *Cache
+}
+
+func copyRoot(root interface{}) interface{} {
+ var prevRootCopy interface{}
+ if b, ok := root.([]byte); ok {
+ prevRootCopy = ethutil.CopyBytes(b)
+ } else {
+ prevRootCopy = root
+ }
+
+ return prevRootCopy
+}
+
+func New(db ethutil.Database, Root interface{}) *Trie {
+ // Make absolute sure the root is copied
+ r := copyRoot(Root)
+ p := copyRoot(Root)
+
+ return &Trie{cache: NewCache(db), Root: r, prevRoot: p}
+}
+
+/*
+ * Public (query) interface functions
+ */
+
+func (t *Trie) Update(key, value string) {
+ t.mut.Lock()
+ defer t.mut.Unlock()
+
+ k := CompactHexDecode(key)
+
+ root := t.UpdateState(t.Root, k, value)
+ switch root.(type) {
+ case string:
+ t.Root = root
+ case []byte:
+ t.Root = root
+ default:
+ t.Root = t.cache.PutValue(root, true)
+ }
+}
+
+func (t *Trie) Get(key string) string {
+ t.mut.Lock()
+ defer t.mut.Unlock()
+
+ k := CompactHexDecode(key)
+ c := ethutil.NewValue(t.getState(t.Root, k))
+
+ return c.Str()
+}
+
+func (t *Trie) Delete(key string) {
+ t.mut.Lock()
+ defer t.mut.Unlock()
+
+ k := CompactHexDecode(key)
+
+ root := t.deleteState(t.Root, k)
+ switch root.(type) {
+ case string:
+ t.Root = root
+ case []byte:
+ t.Root = root
+ default:
+ t.Root = t.cache.PutValue(root, true)
+ }
+}
+
+// Simple compare function which creates a rlp value out of the evaluated objects
+func (t *Trie) Cmp(trie *Trie) bool {
+ return ethutil.NewValue(t.Root).Cmp(ethutil.NewValue(trie.Root))
+}
+
+// Returns a copy of this trie
+func (t *Trie) Copy() *Trie {
+ trie := New(t.cache.db, t.Root)
+ for key, node := range t.cache.nodes {
+ trie.cache.nodes[key] = node.Copy()
+ }
+
+ return trie
+}
+
+// Save the cached value to the database.
+func (t *Trie) Sync() {
+ t.cache.Commit()
+ t.prevRoot = copyRoot(t.Root)
+}
+
+func (t *Trie) Undo() {
+ t.cache.Undo()
+ t.Root = t.prevRoot
+}
+
+func (t *Trie) Cache() *Cache {
+ return t.cache
+}
+
+func (t *Trie) getState(node interface{}, key []byte) interface{} {
+ n := ethutil.NewValue(node)
+ // Return the node if key is empty (= found)
+ if len(key) == 0 || n.IsNil() || n.Len() == 0 {
+ return node
+ }
+
+ currentNode := t.getNode(node)
+ length := currentNode.Len()
+
+ if length == 0 {
+ return ""
+ } else if length == 2 {
+ // Decode the key
+ k := CompactDecode(currentNode.Get(0).Str())
+ v := currentNode.Get(1).Raw()
+
+ if len(key) >= len(k) && bytes.Equal(k, key[:len(k)]) { //CompareIntSlice(k, key[:len(k)]) {
+ return t.getState(v, key[len(k):])
+ } else {
+ return ""
+ }
+ } else if length == 17 {
+ return t.getState(currentNode.Get(int(key[0])).Raw(), key[1:])
+ }
+
+ // It shouldn't come this far
+ panic("unexpected return")
+}
+
+func (t *Trie) getNode(node interface{}) *ethutil.Value {
+ n := ethutil.NewValue(node)
+
+ if !n.Get(0).IsNil() {
+ return n
+ }
+
+ str := n.Str()
+ if len(str) == 0 {
+ return n
+ } else if len(str) < 32 {
+ return ethutil.NewValueFromBytes([]byte(str))
+ }
+
+ data := t.cache.Get(n.Bytes())
+
+ return data
+}
+
+func (t *Trie) UpdateState(node interface{}, key []byte, value string) interface{} {
+ return t.InsertState(node, key, value)
+}
+
+func (t *Trie) Put(node interface{}) interface{} {
+ return t.cache.Put(node)
+
+}
+
+func EmptyStringSlice(l int) []interface{} {
+ slice := make([]interface{}, l)
+ for i := 0; i < l; i++ {
+ slice[i] = ""
+ }
+ return slice
+}
+
+func (t *Trie) InsertState(node interface{}, key []byte, value interface{}) interface{} {
+ if len(key) == 0 {
+ return value
+ }
+
+ // New node
+ n := ethutil.NewValue(node)
+ if node == nil || n.Len() == 0 {
+ newNode := []interface{}{CompactEncode(key), value}
+
+ return t.Put(newNode)
+ }
+
+ currentNode := t.getNode(node)
+ // Check for "special" 2 slice type node
+ if currentNode.Len() == 2 {
+ // Decode the key
+
+ k := CompactDecode(currentNode.Get(0).Str())
+ v := currentNode.Get(1).Raw()
+
+ // Matching key pair (ie. there's already an object with this key)
+ if bytes.Equal(k, key) { //CompareIntSlice(k, key) {
+ newNode := []interface{}{CompactEncode(key), value}
+ return t.Put(newNode)
+ }
+
+ var newHash interface{}
+ matchingLength := MatchingNibbleLength(key, k)
+ if matchingLength == len(k) {
+ // Insert the hash, creating a new node
+ newHash = t.InsertState(v, key[matchingLength:], value)
+ } else {
+ // Expand the 2 length slice to a 17 length slice
+ oldNode := t.InsertState("", k[matchingLength+1:], v)
+ newNode := t.InsertState("", key[matchingLength+1:], value)
+ // Create an expanded slice
+ scaledSlice := EmptyStringSlice(17)
+ // Set the copied and new node
+ scaledSlice[k[matchingLength]] = oldNode
+ scaledSlice[key[matchingLength]] = newNode
+
+ newHash = t.Put(scaledSlice)
+ }
+
+ if matchingLength == 0 {
+ // End of the chain, return
+ return newHash
+ } else {
+ newNode := []interface{}{CompactEncode(key[:matchingLength]), newHash}
+ return t.Put(newNode)
+ }
+ } else {
+
+ // Copy the current node over to the new node and replace the first nibble in the key
+ newNode := EmptyStringSlice(17)
+
+ for i := 0; i < 17; i++ {
+ cpy := currentNode.Get(i).Raw()
+ if cpy != nil {
+ newNode[i] = cpy
+ }
+ }
+
+ newNode[key[0]] = t.InsertState(currentNode.Get(int(key[0])).Raw(), key[1:], value)
+
+ return t.Put(newNode)
+ }
+
+ panic("unexpected end")
+}
+
+func (t *Trie) deleteState(node interface{}, key []byte) interface{} {
+ if len(key) == 0 {
+ return ""
+ }
+
+ // New node
+ n := ethutil.NewValue(node)
+ //if node == nil || (n.Type() == reflect.String && (n.Str() == "" || n.Get(0).IsNil())) || n.Len() == 0 {
+ if node == nil || n.Len() == 0 {
+ //return nil
+ //fmt.Printf("<empty ret> %x %d\n", n, len(n.Bytes()))
+
+ return ""
+ }
+
+ currentNode := t.getNode(node)
+ // Check for "special" 2 slice type node
+ if currentNode.Len() == 2 {
+ // Decode the key
+ k := CompactDecode(currentNode.Get(0).Str())
+ v := currentNode.Get(1).Raw()
+
+ // Matching key pair (ie. there's already an object with this key)
+ if bytes.Equal(k, key) { //CompareIntSlice(k, key) {
+ //fmt.Printf("<delete ret> %x\n", v)
+
+ return ""
+ } else if bytes.Equal(key[:len(k)], k) { //CompareIntSlice(key[:len(k)], k) {
+ hash := t.deleteState(v, key[len(k):])
+ child := t.getNode(hash)
+
+ var newNode []interface{}
+ if child.Len() == 2 {
+ newKey := append(k, CompactDecode(child.Get(0).Str())...)
+ newNode = []interface{}{CompactEncode(newKey), child.Get(1).Raw()}
+ } else {
+ newNode = []interface{}{currentNode.Get(0).Str(), hash}
+ }
+
+ //fmt.Printf("%x\n", newNode)
+
+ return t.Put(newNode)
+ } else {
+ return node
+ }
+ } else {
+ // Copy the current node over to the new node and replace the first nibble in the key
+ n := EmptyStringSlice(17)
+ var newNode []interface{}
+
+ for i := 0; i < 17; i++ {
+ cpy := currentNode.Get(i).Raw()
+ if cpy != nil {
+ n[i] = cpy
+ }
+ }
+
+ n[key[0]] = t.deleteState(n[key[0]], key[1:])
+ amount := -1
+ for i := 0; i < 17; i++ {
+ if n[i] != "" {
+ if amount == -1 {
+ amount = i
+ } else {
+ amount = -2
+ }
+ }
+ }
+ if amount == 16 {
+ newNode = []interface{}{CompactEncode([]byte{16}), n[amount]}
+ } else if amount >= 0 {
+ child := t.getNode(n[amount])
+ if child.Len() == 17 {
+ newNode = []interface{}{CompactEncode([]byte{byte(amount)}), n[amount]}
+ } else if child.Len() == 2 {
+ key := append([]byte{byte(amount)}, CompactDecode(child.Get(0).Str())...)
+ newNode = []interface{}{CompactEncode(key), child.Get(1).Str()}
+ }
+
+ } else {
+ newNode = n
+ }
+
+ //fmt.Printf("%x\n", newNode)
+ return t.Put(newNode)
+ }
+
+ panic("unexpected return")
+}
+
+type TrieIterator struct {
+ trie *Trie
+ key string
+ value string
+
+ shas [][]byte
+ values []string
+
+ lastNode []byte
+}
+
+func (t *Trie) NewIterator() *TrieIterator {
+ return &TrieIterator{trie: t}
+}
+
+func (self *Trie) Iterator() *Iterator {
+ return NewIterator(self)
+}
+
+// Some time in the near future this will need refactoring :-)
+// XXX Note to self, IsSlice == inline node. Str == sha3 to node
+func (it *TrieIterator) workNode(currentNode *ethutil.Value) {
+ if currentNode.Len() == 2 {
+ k := CompactDecode(currentNode.Get(0).Str())
+
+ if currentNode.Get(1).Str() == "" {
+ it.workNode(currentNode.Get(1))
+ } else {
+ if k[len(k)-1] == 16 {
+ it.values = append(it.values, currentNode.Get(1).Str())
+ } else {
+ it.shas = append(it.shas, currentNode.Get(1).Bytes())
+ it.getNode(currentNode.Get(1).Bytes())
+ }
+ }
+ } else {
+ for i := 0; i < currentNode.Len(); i++ {
+ if i == 16 && currentNode.Get(i).Len() != 0 {
+ it.values = append(it.values, currentNode.Get(i).Str())
+ } else {
+ if currentNode.Get(i).Str() == "" {
+ it.workNode(currentNode.Get(i))
+ } else {
+ val := currentNode.Get(i).Str()
+ if val != "" {
+ it.shas = append(it.shas, currentNode.Get(1).Bytes())
+ it.getNode([]byte(val))
+ }
+ }
+ }
+ }
+ }
+}
+
+func (it *TrieIterator) getNode(node []byte) {
+ currentNode := it.trie.cache.Get(node)
+ it.workNode(currentNode)
+}
+
+func (it *TrieIterator) Collect() [][]byte {
+ if it.trie.Root == "" {
+ return nil
+ }
+
+ it.getNode(ethutil.NewValue(it.trie.Root).Bytes())
+
+ return it.shas
+}
+
+func (it *TrieIterator) Purge() int {
+ shas := it.Collect()
+ for _, sha := range shas {
+ it.trie.cache.Delete(sha)
+ }
+ return len(it.values)
+}
+
+func (it *TrieIterator) Key() string {
+ return ""
+}
+
+func (it *TrieIterator) Value() string {
+ return ""
+}
+
+type EachCallback func(key string, node *ethutil.Value)
+
+func (it *TrieIterator) Each(cb EachCallback) {
+ it.fetchNode(nil, ethutil.NewValue(it.trie.Root).Bytes(), cb)
+}
+
+func (it *TrieIterator) fetchNode(key []byte, node []byte, cb EachCallback) {
+ it.iterateNode(key, it.trie.cache.Get(node), cb)
+}
+
+func (it *TrieIterator) iterateNode(key []byte, currentNode *ethutil.Value, cb EachCallback) {
+ if currentNode.Len() == 2 {
+ k := CompactDecode(currentNode.Get(0).Str())
+
+ pk := append(key, k...)
+ if currentNode.Get(1).Len() != 0 && currentNode.Get(1).Str() == "" {
+ it.iterateNode(pk, currentNode.Get(1), cb)
+ } else {
+ if k[len(k)-1] == 16 {
+ cb(DecodeCompact(pk), currentNode.Get(1))
+ } else {
+ it.fetchNode(pk, currentNode.Get(1).Bytes(), cb)
+ }
+ }
+ } else {
+ for i := 0; i < currentNode.Len(); i++ {
+ pk := append(key, byte(i))
+ if i == 16 && currentNode.Get(i).Len() != 0 {
+ cb(DecodeCompact(pk), currentNode.Get(i))
+ } else {
+ if currentNode.Get(i).Len() != 0 && currentNode.Get(i).Str() == "" {
+ it.iterateNode(pk, currentNode.Get(i), cb)
+ } else {
+ val := currentNode.Get(i).Str()
+ if val != "" {
+ it.fetchNode(pk, []byte(val), cb)
+ }
+ }
+ }
+ }
+ }
+}
diff --git a/ethtrie/trie_test.go b/ethtrie/trie_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..a70916483246ec38304ed7e6244f9164c5946585
--- /dev/null
+++ b/ethtrie/trie_test.go
@@ -0,0 +1,434 @@
+package ethtrie
+
+import (
+ "bytes"
+ "encoding/hex"
+ "encoding/json"
+ "fmt"
+ "io/ioutil"
+ "math/rand"
+ "net/http"
+ "reflect"
+ "testing"
+ "time"
+
+ "github.com/ethereum/go-ethereum/ethutil"
+)
+
+const LONG_WORD = "1234567890abcdefghijklmnopqrstuvwxxzABCEFGHIJKLMNOPQRSTUVWXYZ"
+
+type MemDatabase struct {
+ db map[string][]byte
+}
+
+func NewMemDatabase() (*MemDatabase, error) {
+ db := &MemDatabase{db: make(map[string][]byte)}
+ return db, nil
+}
+func (db *MemDatabase) Put(key []byte, value []byte) {
+ db.db[string(key)] = value
+}
+func (db *MemDatabase) Get(key []byte) ([]byte, error) {
+ return db.db[string(key)], nil
+}
+func (db *MemDatabase) Delete(key []byte) error {
+ delete(db.db, string(key))
+ return nil
+}
+func (db *MemDatabase) Print() {}
+func (db *MemDatabase) Close() {}
+func (db *MemDatabase) LastKnownTD() []byte { return nil }
+
+func NewTrie() (*MemDatabase, *Trie) {
+ db, _ := NewMemDatabase()
+ return db, New(db, "")
+}
+
+func TestTrieSync(t *testing.T) {
+ db, trie := NewTrie()
+
+ trie.Update("dog", LONG_WORD)
+ if len(db.db) != 0 {
+ t.Error("Expected no data in database")
+ }
+
+ trie.Sync()
+ if len(db.db) == 0 {
+ t.Error("Expected data to be persisted")
+ }
+}
+
+func TestTrieDirtyTracking(t *testing.T) {
+ _, trie := NewTrie()
+ trie.Update("dog", LONG_WORD)
+ if !trie.cache.IsDirty {
+ t.Error("Expected trie to be dirty")
+ }
+
+ trie.Sync()
+ if trie.cache.IsDirty {
+ t.Error("Expected trie not to be dirty")
+ }
+
+ trie.Update("test", LONG_WORD)
+ trie.cache.Undo()
+ if trie.cache.IsDirty {
+ t.Error("Expected trie not to be dirty")
+ }
+
+}
+
+func TestTrieReset(t *testing.T) {
+ _, trie := NewTrie()
+
+ trie.Update("cat", LONG_WORD)
+ if len(trie.cache.nodes) == 0 {
+ t.Error("Expected cached nodes")
+ }
+
+ trie.cache.Undo()
+
+ if len(trie.cache.nodes) != 0 {
+ t.Error("Expected no nodes after undo")
+ }
+}
+
+func TestTrieGet(t *testing.T) {
+ _, trie := NewTrie()
+
+ trie.Update("cat", LONG_WORD)
+ x := trie.Get("cat")
+ if x != LONG_WORD {
+ t.Error("expected %s, got %s", LONG_WORD, x)
+ }
+}
+
+func TestTrieUpdating(t *testing.T) {
+ _, trie := NewTrie()
+ trie.Update("cat", LONG_WORD)
+ trie.Update("cat", LONG_WORD+"1")
+ x := trie.Get("cat")
+ if x != LONG_WORD+"1" {
+ t.Error("expected %S, got %s", LONG_WORD+"1", x)
+ }
+}
+
+func TestTrieCmp(t *testing.T) {
+ _, trie1 := NewTrie()
+ _, trie2 := NewTrie()
+
+ trie1.Update("doge", LONG_WORD)
+ trie2.Update("doge", LONG_WORD)
+ if !trie1.Cmp(trie2) {
+ t.Error("Expected tries to be equal")
+ }
+
+ trie1.Update("dog", LONG_WORD)
+ trie2.Update("cat", LONG_WORD)
+ if trie1.Cmp(trie2) {
+ t.Errorf("Expected tries not to be equal %x %x", trie1.Root, trie2.Root)
+ }
+}
+
+func TestTrieDelete(t *testing.T) {
+ _, trie := NewTrie()
+ trie.Update("cat", LONG_WORD)
+ exp := trie.Root
+ trie.Update("dog", LONG_WORD)
+ trie.Delete("dog")
+ if !reflect.DeepEqual(exp, trie.Root) {
+ t.Errorf("Expected tries to be equal %x : %x", exp, trie.Root)
+ }
+
+ trie.Update("dog", LONG_WORD)
+ exp = trie.Root
+ trie.Update("dude", LONG_WORD)
+ trie.Delete("dude")
+ if !reflect.DeepEqual(exp, trie.Root) {
+ t.Errorf("Expected tries to be equal %x : %x", exp, trie.Root)
+ }
+}
+
+func TestTrieDeleteWithValue(t *testing.T) {
+ _, trie := NewTrie()
+ trie.Update("c", LONG_WORD)
+ exp := trie.Root
+ trie.Update("ca", LONG_WORD)
+ trie.Update("cat", LONG_WORD)
+ trie.Delete("ca")
+ trie.Delete("cat")
+ if !reflect.DeepEqual(exp, trie.Root) {
+ t.Errorf("Expected tries to be equal %x : %x", exp, trie.Root)
+ }
+
+}
+
+func TestTriePurge(t *testing.T) {
+ _, trie := NewTrie()
+ trie.Update("c", LONG_WORD)
+ trie.Update("ca", LONG_WORD)
+ trie.Update("cat", LONG_WORD)
+
+ lenBefore := len(trie.cache.nodes)
+ it := trie.NewIterator()
+ if num := it.Purge(); num != 3 {
+ t.Errorf("Expected purge to return 3, got %d", num)
+ }
+
+ if lenBefore == len(trie.cache.nodes) {
+ t.Errorf("Expected cached nodes to be deleted")
+ }
+}
+
+func h(str string) string {
+ d, err := hex.DecodeString(str)
+ if err != nil {
+ panic(err)
+ }
+
+ return string(d)
+}
+
+func get(in string) (out string) {
+ if len(in) > 2 && in[:2] == "0x" {
+ out = h(in[2:])
+ } else {
+ out = in
+ }
+
+ return
+}
+
+type Test struct {
+ Name string
+ In map[string]string
+ Root string
+}
+
+func CreateTest(name string, data []byte) (Test, error) {
+ t := Test{Name: name}
+ err := json.Unmarshal(data, &t)
+ if err != nil {
+ return Test{}, fmt.Errorf("%v", err)
+ }
+
+ return t, nil
+}
+
+func CreateTests(uri string, cb func(Test)) map[string]Test {
+ resp, err := http.Get(uri)
+ if err != nil {
+ panic(err)
+ }
+ defer resp.Body.Close()
+
+ data, err := ioutil.ReadAll(resp.Body)
+
+ var objmap map[string]*json.RawMessage
+ err = json.Unmarshal(data, &objmap)
+ if err != nil {
+ panic(err)
+ }
+
+ tests := make(map[string]Test)
+ for name, testData := range objmap {
+ test, err := CreateTest(name, *testData)
+ if err != nil {
+ panic(err)
+ }
+
+ if cb != nil {
+ cb(test)
+ }
+ tests[name] = test
+ }
+
+ return tests
+}
+
+func RandomData() [][]string {
+ data := [][]string{
+ {"0x000000000000000000000000ec4f34c97e43fbb2816cfd95e388353c7181dab1", "0x4e616d6552656700000000000000000000000000000000000000000000000000"},
+ {"0x0000000000000000000000000000000000000000000000000000000000000045", "0x22b224a1420a802ab51d326e29fa98e34c4f24ea"},
+ {"0x0000000000000000000000000000000000000000000000000000000000000046", "0x67706c2076330000000000000000000000000000000000000000000000000000"},
+ {"0x000000000000000000000000697c7b8c961b56f675d570498424ac8de1a918f6", "0x6f6f6f6820736f2067726561742c207265616c6c6c793f000000000000000000"},
+ {"0x0000000000000000000000007ef9e639e2733cb34e4dfc576d4b23f72db776b2", "0x4655474156000000000000000000000000000000000000000000000000000000"},
+ {"0x6f6f6f6820736f2067726561742c207265616c6c6c793f000000000000000000", "0x697c7b8c961b56f675d570498424ac8de1a918f6"},
+ {"0x4655474156000000000000000000000000000000000000000000000000000000", "0x7ef9e639e2733cb34e4dfc576d4b23f72db776b2"},
+ {"0x4e616d6552656700000000000000000000000000000000000000000000000000", "0xec4f34c97e43fbb2816cfd95e388353c7181dab1"},
+ }
+
+ var c [][]string
+ for len(data) != 0 {
+ e := rand.Intn(len(data))
+ c = append(c, data[e])
+
+ copy(data[e:], data[e+1:])
+ data[len(data)-1] = nil
+ data = data[:len(data)-1]
+ }
+
+ return c
+}
+
+const MaxTest = 1000
+
+// This test insert data in random order and seeks to find indifferences between the different tries
+func TestRegression(t *testing.T) {
+ rand.Seed(time.Now().Unix())
+
+ roots := make(map[string]int)
+ for i := 0; i < MaxTest; i++ {
+ _, trie := NewTrie()
+ data := RandomData()
+
+ for _, test := range data {
+ trie.Update(test[0], test[1])
+ }
+ trie.Delete("0x4e616d6552656700000000000000000000000000000000000000000000000000")
+
+ roots[string(trie.Root.([]byte))] += 1
+ }
+
+ if len(roots) > 1 {
+ for root, num := range roots {
+ t.Errorf("%x => %d\n", root, num)
+ }
+ }
+}
+
+func TestDelete(t *testing.T) {
+ _, trie := NewTrie()
+
+ trie.Update("a", "jeffreytestlongstring")
+ trie.Update("aa", "otherstring")
+ trie.Update("aaa", "othermorestring")
+ trie.Update("aabbbbccc", "hithere")
+ trie.Update("abbcccdd", "hstanoehutnaheoustnh")
+ trie.Update("rnthaoeuabbcccdd", "hstanoehutnaheoustnh")
+ trie.Update("rneuabbcccdd", "hstanoehutnaheoustnh")
+ trie.Update("rneuabboeusntahoeucccdd", "hstanoehutnaheoustnh")
+ trie.Update("rnxabboeusntahoeucccdd", "hstanoehutnaheoustnh")
+ trie.Delete("aaboaestnuhbccc")
+ trie.Delete("a")
+ trie.Update("a", "nthaonethaosentuh")
+ trie.Update("c", "shtaosntehua")
+ trie.Delete("a")
+ trie.Update("aaaa", "testmegood")
+
+ _, t2 := NewTrie()
+ trie.NewIterator().Each(func(key string, v *ethutil.Value) {
+ if key == "aaaa" {
+ t2.Update(key, v.Str())
+ } else {
+ t2.Update(key, v.Str())
+ }
+ })
+
+ a := ethutil.NewValue(trie.Root).Bytes()
+ b := ethutil.NewValue(t2.Root).Bytes()
+
+ if bytes.Compare(a, b) != 0 {
+ t.Errorf("Expected %x and %x to be equal", a, b)
+ }
+}
+
+func TestTerminator(t *testing.T) {
+ key := CompactDecode("hello")
+ if !HasTerm(key) {
+ t.Errorf("Expected %v to have a terminator", key)
+ }
+}
+
+func TestIt(t *testing.T) {
+ _, trie := NewTrie()
+ trie.Update("cat", "cat")
+ trie.Update("doge", "doge")
+ trie.Update("wallace", "wallace")
+ it := trie.Iterator()
+
+ inputs := []struct {
+ In, Out string
+ }{
+ {"", "cat"},
+ {"bobo", "cat"},
+ {"c", "cat"},
+ {"car", "cat"},
+ {"catering", "doge"},
+ {"w", "wallace"},
+ {"wallace123", ""},
+ }
+
+ for _, test := range inputs {
+ res := string(it.Next(test.In))
+ if res != test.Out {
+ t.Errorf(test.In, "failed. Got", res, "Expected", test.Out)
+ }
+ }
+}
+
+func TestBeginsWith(t *testing.T) {
+ a := CompactDecode("hello")
+ b := CompactDecode("hel")
+
+ if BeginsWith(a, b) {
+ t.Errorf("Expected %x to begin with %x", a, b)
+ }
+
+ if BeginsWith(b, a) {
+ t.Errorf("Expected %x not to begin with %x", b, a)
+ }
+}
+
+/*
+func TestRndCase(t *testing.T) {
+ _, trie := NewTrie()
+
+ data := []struct{ k, v string }{
+ {"0000000000000000000000000000000000000000000000000000000000000001", "a07573657264617461000000000000000000000000000000000000000000000000"},
+ {"0000000000000000000000000000000000000000000000000000000000000003", "8453bb5b31"},
+ {"0000000000000000000000000000000000000000000000000000000000000004", "850218711a00"},
+ {"0000000000000000000000000000000000000000000000000000000000000005", "9462d7705bd0b3ecbc51a8026a25597cb28a650c79"},
+ {"0000000000000000000000000000000000000000000000000000000000000010", "947e70f9460402290a3e487dae01f610a1a8218fda"},
+ {"0000000000000000000000000000000000000000000000000000000000000111", "01"},
+ {"0000000000000000000000000000000000000000000000000000000000000112", "a053656e6174650000000000000000000000000000000000000000000000000000"},
+ {"0000000000000000000000000000000000000000000000000000000000000113", "a053656e6174650000000000000000000000000000000000000000000000000000"},
+ {"53656e6174650000000000000000000000000000000000000000000000000000", "94977e3f62f5e1ed7953697430303a3cfa2b5b736e"},
+ }
+ for _, e := range data {
+ trie.Update(string(ethutil.Hex2Bytes(e.k)), string(ethutil.Hex2Bytes(e.v)))
+ }
+
+ fmt.Printf("root after update %x\n", trie.Root)
+ trie.NewIterator().Each(func(k string, v *ethutil.Value) {
+ fmt.Printf("%x %x\n", k, v.Bytes())
+ })
+
+ data = []struct{ k, v string }{
+ {"0000000000000000000000000000000000000000000000000000000000000112", ""},
+ {"436974697a656e73000000000000000000000000000000000000000000000001", ""},
+ {"436f757274000000000000000000000000000000000000000000000000000002", ""},
+ {"53656e6174650000000000000000000000000000000000000000000000000000", ""},
+ {"436f757274000000000000000000000000000000000000000000000000000000", ""},
+ {"53656e6174650000000000000000000000000000000000000000000000000001", ""},
+ {"0000000000000000000000000000000000000000000000000000000000000113", ""},
+ {"436974697a656e73000000000000000000000000000000000000000000000000", ""},
+ {"436974697a656e73000000000000000000000000000000000000000000000002", ""},
+ {"436f757274000000000000000000000000000000000000000000000000000001", ""},
+ {"0000000000000000000000000000000000000000000000000000000000000111", ""},
+ {"53656e6174650000000000000000000000000000000000000000000000000002", ""},
+ }
+
+ for _, e := range data {
+ trie.Delete(string(ethutil.Hex2Bytes(e.k)))
+ }
+
+ fmt.Printf("root after delete %x\n", trie.Root)
+
+ trie.NewIterator().Each(func(k string, v *ethutil.Value) {
+ fmt.Printf("%x %x\n", k, v.Bytes())
+ })
+
+ fmt.Printf("%x\n", trie.Get(string(ethutil.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000001"))))
+}
+*/
diff --git a/ethutil/.gitignore b/ethutil/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..f725d58d14f7d1b6a8c41c45f78b4f38f529ae9e
--- /dev/null
+++ b/ethutil/.gitignore
@@ -0,0 +1,12 @@
+# See http://help.github.com/ignore-files/ for more about ignoring files.
+#
+# If you find yourself ignoring temporary files generated by your text editor
+# or operating system, you probably want to add a global ignore instead:
+# git config --global core.excludesfile ~/.gitignore_global
+
+/tmp
+*/**/*un~
+*un~
+.DS_Store
+*/**/.DS_Store
+
diff --git a/ethutil/.travis.yml b/ethutil/.travis.yml
new file mode 100644
index 0000000000000000000000000000000000000000..69359072d9650ed325c87fe76d18c4a6c62a352c
--- /dev/null
+++ b/ethutil/.travis.yml
@@ -0,0 +1,3 @@
+language: go
+go:
+ - 1.2
diff --git a/ethutil/README.md b/ethutil/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..1ed56b71ba16d0f93ac1de2d7ea5bc22cae516d5
--- /dev/null
+++ b/ethutil/README.md
@@ -0,0 +1,139 @@
+# ethutil
+
+[](https://travis-ci.org/ethereum/go-ethereum)
+
+The ethutil package contains the ethereum utility library.
+
+# Installation
+
+`go get github.com/ethereum/ethutil-go`
+
+# Usage
+
+## RLP (Recursive Linear Prefix) Encoding
+
+RLP Encoding is an encoding scheme utilized by the Ethereum project. It
+encodes any native value or list to string.
+
+More in depth information about the Encoding scheme see the [Wiki](http://wiki.ethereum.org/index.php/RLP)
+article.
+
+```go
+rlp := ethutil.Encode("doge")
+fmt.Printf("%q\n", rlp) // => "\0x83dog"
+
+rlp = ethutil.Encode([]interface{}{"dog", "cat"})
+fmt.Printf("%q\n", rlp) // => "\0xc8\0x83dog\0x83cat"
+decoded := ethutil.Decode(rlp)
+fmt.Println(decoded) // => ["dog" "cat"]
+```
+
+## Patricia Trie
+
+Patricie Tree is a merkle trie utilized by the Ethereum project.
+
+More in depth information about the (modified) Patricia Trie can be
+found on the [Wiki](http://wiki.ethereum.org/index.php/Patricia_Tree).
+
+The patricia trie uses a db as backend and could be anything as long as
+it satisfies the Database interface found in `ethutil/db.go`.
+
+```go
+db := NewDatabase()
+
+// db, root
+trie := ethutil.NewTrie(db, "")
+
+trie.Put("puppy", "dog")
+trie.Put("horse", "stallion")
+trie.Put("do", "verb")
+trie.Put("doge", "coin")
+
+// Look up the key "do" in the trie
+out := trie.Get("do")
+fmt.Println(out) // => verb
+
+trie.Delete("puppy")
+```
+
+The patricia trie, in combination with RLP, provides a robust,
+cryptographically authenticated data structure that can be used to store
+all (key, value) bindings.
+
+```go
+// ... Create db/trie
+
+// Note that RLP uses interface slices as list
+value := ethutil.Encode([]interface{}{"one", 2, "three", []interface{}{42}})
+// Store the RLP encoded value of the list
+trie.Put("mykey", value)
+```
+
+## Value
+
+Value is a Generic Value which is used in combination with RLP data or
+`([])interface{}` structures. It may serve as a bridge between RLP data
+and actual real values and takes care of all the type checking and
+casting. Unlike Go's `reflect.Value` it does not panic if it's unable to
+cast to the requested value. It simple returns the base value of that
+type (e.g. `Slice()` returns []interface{}, `Uint()` return 0, etc).
+
+### Creating a new Value
+
+`NewEmptyValue()` returns a new \*Value with it's initial value set to a
+`[]interface{}`
+
+`AppendList()` appends a list to the current value.
+
+`Append(v)` appends the value (v) to the current value/list.
+
+```go
+val := ethutil.NewEmptyValue().Append(1).Append("2")
+val.AppendList().Append(3)
+```
+
+### Retrieving values
+
+`Get(i)` returns the `i` item in the list.
+
+`Uint()` returns the value as an unsigned int64.
+
+`Slice()` returns the value as a interface slice.
+
+`Str()` returns the value as a string.
+
+`Bytes()` returns the value as a byte slice.
+
+`Len()` assumes current to be a slice and returns its length.
+
+`Byte()` returns the value as a single byte.
+
+```go
+val := ethutil.NewValue([]interface{}{1,"2",[]interface{}{3}})
+val.Get(0).Uint() // => 1
+val.Get(1).Str() // => "2"
+s := val.Get(2) // => Value([]interface{}{3})
+s.Get(0).Uint() // => 3
+```
+
+## Decoding
+
+Decoding streams of RLP data is simplified
+
+```go
+val := ethutil.NewValueFromBytes(rlpData)
+val.Get(0).Uint()
+```
+
+## Encoding
+
+Encoding from Value to RLP is done with the `Encode` method. The
+underlying value can be anything RLP can encode (int, str, lists, bytes)
+
+```go
+val := ethutil.NewValue([]interface{}{1,"2",[]interface{}{3}})
+rlp := val.Encode()
+// Store the rlp data
+Store(rlp)
+```
diff --git a/ethutil/big.go b/ethutil/big.go
new file mode 100644
index 0000000000000000000000000000000000000000..bdcf86421fc9fb1c7987a4f4417d732880ce7b6e
--- /dev/null
+++ b/ethutil/big.go
@@ -0,0 +1,104 @@
+package ethutil
+
+import "math/big"
+
+var MaxInt256 *big.Int = BigD(Hex2Bytes("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"))
+
+// Big pow
+//
+// Returns the power of two big integers
+func BigPow(a, b int) *big.Int {
+ c := new(big.Int)
+ c.Exp(big.NewInt(int64(a)), big.NewInt(int64(b)), big.NewInt(0))
+
+ return c
+}
+
+// Big
+//
+// Shortcut for new(big.Int).SetString(..., 0)
+func Big(num string) *big.Int {
+ n := new(big.Int)
+ n.SetString(num, 0)
+
+ return n
+}
+
+// BigD
+//
+// Shortcut for new(big.Int).SetBytes(...)
+func BigD(data []byte) *big.Int {
+ n := new(big.Int)
+ n.SetBytes(data)
+
+ return n
+}
+
+// To256
+//
+// "cast" the big int to a 256 big int (i.e., limit to)
+var tt256 = new(big.Int).Lsh(big.NewInt(1), 256)
+var tt256m1 = new(big.Int).Sub(new(big.Int).Lsh(big.NewInt(1), 256), big.NewInt(1))
+var tt255 = new(big.Int).Lsh(big.NewInt(1), 255)
+
+func U256(x *big.Int) *big.Int {
+ //if x.Cmp(Big0) < 0 {
+ // return new(big.Int).Add(tt256, x)
+ // }
+
+ x.And(x, tt256m1)
+
+ return x
+}
+
+func S256(x *big.Int) *big.Int {
+ if x.Cmp(tt255) < 0 {
+ return x
+ } else {
+ // We don't want to modify x, ever
+ return new(big.Int).Sub(x, tt256)
+ }
+}
+
+// Big to bytes
+//
+// Returns the bytes of a big integer with the size specified by **base**
+// Attempts to pad the byte array with zeros.
+func BigToBytes(num *big.Int, base int) []byte {
+ ret := make([]byte, base/8)
+
+ if len(num.Bytes()) > base/8 {
+ return num.Bytes()
+ }
+
+ return append(ret[:len(ret)-len(num.Bytes())], num.Bytes()...)
+}
+
+// Big copy
+//
+// Creates a copy of the given big integer
+func BigCopy(src *big.Int) *big.Int {
+ return new(big.Int).Set(src)
+}
+
+// Big max
+//
+// Returns the maximum size big integer
+func BigMax(x, y *big.Int) *big.Int {
+ if x.Cmp(y) <= 0 {
+ return y
+ }
+
+ return x
+}
+
+// Big min
+//
+// Returns the minimum size big integer
+func BigMin(x, y *big.Int) *big.Int {
+ if x.Cmp(y) >= 0 {
+ return y
+ }
+
+ return x
+}
diff --git a/ethutil/bytes.go b/ethutil/bytes.go
new file mode 100644
index 0000000000000000000000000000000000000000..bd294f28a7ac6b6a1cfaa67c0e364666011cd054
--- /dev/null
+++ b/ethutil/bytes.go
@@ -0,0 +1,234 @@
+package ethutil
+
+import (
+ "bytes"
+ "encoding/binary"
+ "encoding/hex"
+ "fmt"
+ "math/big"
+ "strings"
+)
+
+type Bytes []byte
+
+func (self Bytes) String() string {
+ return string(self)
+}
+
+func DeleteFromByteSlice(s [][]byte, hash []byte) [][]byte {
+ for i, h := range s {
+ if bytes.Compare(h, hash) == 0 {
+ return append(s[:i:i], s[i+1:]...)
+ }
+ }
+
+ return s
+}
+
+// Number to bytes
+//
+// Returns the number in bytes with the specified base
+func NumberToBytes(num interface{}, bits int) []byte {
+ buf := new(bytes.Buffer)
+ err := binary.Write(buf, binary.BigEndian, num)
+ if err != nil {
+ fmt.Println("NumberToBytes failed:", err)
+ }
+
+ return buf.Bytes()[buf.Len()-(bits/8):]
+}
+
+// Bytes to number
+//
+// Attempts to cast a byte slice to a unsigned integer
+func BytesToNumber(b []byte) uint64 {
+ var number uint64
+
+ // Make sure the buffer is 64bits
+ data := make([]byte, 8)
+ data = append(data[:len(b)], b...)
+
+ buf := bytes.NewReader(data)
+ err := binary.Read(buf, binary.BigEndian, &number)
+ if err != nil {
+ fmt.Println("BytesToNumber failed:", err)
+ }
+
+ return number
+}
+
+// Read variable int
+//
+// Read a variable length number in big endian byte order
+func ReadVarInt(buff []byte) (ret uint64) {
+ switch l := len(buff); {
+ case l > 4:
+ d := LeftPadBytes(buff, 8)
+ binary.Read(bytes.NewReader(d), binary.BigEndian, &ret)
+ case l > 2:
+ var num uint32
+ d := LeftPadBytes(buff, 4)
+ binary.Read(bytes.NewReader(d), binary.BigEndian, &num)
+ ret = uint64(num)
+ case l > 1:
+ var num uint16
+ d := LeftPadBytes(buff, 2)
+ binary.Read(bytes.NewReader(d), binary.BigEndian, &num)
+ ret = uint64(num)
+ default:
+ var num uint8
+ binary.Read(bytes.NewReader(buff), binary.BigEndian, &num)
+ ret = uint64(num)
+ }
+
+ return
+}
+
+// Binary length
+//
+// Returns the true binary length of the given number
+func BinaryLength(num int) int {
+ if num == 0 {
+ return 0
+ }
+
+ return 1 + BinaryLength(num>>8)
+}
+
+// Copy bytes
+//
+// Returns an exact copy of the provided bytes
+func CopyBytes(b []byte) (copiedBytes []byte) {
+ copiedBytes = make([]byte, len(b))
+ copy(copiedBytes, b)
+
+ return
+}
+
+func IsHex(str string) bool {
+ l := len(str)
+ return l >= 4 && l%2 == 0 && str[0:2] == "0x"
+}
+
+func Bytes2Hex(d []byte) string {
+ return hex.EncodeToString(d)
+}
+
+func Hex2Bytes(str string) []byte {
+ h, _ := hex.DecodeString(str)
+
+ return h
+}
+
+func StringToByteFunc(str string, cb func(str string) []byte) (ret []byte) {
+ if len(str) > 1 && str[0:2] == "0x" && !strings.Contains(str, "\n") {
+ ret = Hex2Bytes(str[2:])
+ } else {
+ ret = cb(str)
+ }
+
+ return
+}
+
+func FormatData(data string) []byte {
+ if len(data) == 0 {
+ return nil
+ }
+ // Simple stupid
+ d := new(big.Int)
+ if data[0:1] == "\"" && data[len(data)-1:] == "\"" {
+ return RightPadBytes([]byte(data[1:len(data)-1]), 32)
+ } else if len(data) > 1 && data[:2] == "0x" {
+ d.SetBytes(Hex2Bytes(data[2:]))
+ } else {
+ d.SetString(data, 0)
+ }
+
+ return BigToBytes(d, 256)
+}
+
+func ParseData(data ...interface{}) (ret []byte) {
+ for _, item := range data {
+ switch t := item.(type) {
+ case string:
+ var str []byte
+ if IsHex(t) {
+ str = Hex2Bytes(t[2:])
+ } else {
+ str = []byte(t)
+ }
+
+ ret = append(ret, RightPadBytes(str, 32)...)
+ case []byte:
+ ret = append(ret, LeftPadBytes(t, 32)...)
+ }
+ }
+
+ return
+}
+
+func RightPadBytes(slice []byte, l int) []byte {
+ if l < len(slice) {
+ return slice
+ }
+
+ padded := make([]byte, l)
+ copy(padded[0:len(slice)], slice)
+
+ return padded
+}
+
+func LeftPadBytes(slice []byte, l int) []byte {
+ if l < len(slice) {
+ return slice
+ }
+
+ padded := make([]byte, l)
+ copy(padded[l-len(slice):], slice)
+
+ return padded
+}
+
+func LeftPadString(str string, l int) string {
+ if l < len(str) {
+ return str
+ }
+
+ zeros := Bytes2Hex(make([]byte, (l-len(str))/2))
+
+ return zeros + str
+
+}
+
+func RightPadString(str string, l int) string {
+ if l < len(str) {
+ return str
+ }
+
+ zeros := Bytes2Hex(make([]byte, (l-len(str))/2))
+
+ return str + zeros
+
+}
+
+func Address(slice []byte) (addr []byte) {
+ if len(slice) < 20 {
+ addr = LeftPadBytes(slice, 20)
+ } else if len(slice) > 20 {
+ addr = slice[len(slice)-20:]
+ } else {
+ addr = slice
+ }
+
+ addr = CopyBytes(addr)
+
+ return
+}
+
+func ByteSliceToInterface(slice [][]byte) (ret []interface{}) {
+ for _, i := range slice {
+ ret = append(ret, i)
+ }
+
+ return
+}
diff --git a/ethutil/bytes_test.go b/ethutil/bytes_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..381efe7a2c0246ad122407a6212d2c9036bde86e
--- /dev/null
+++ b/ethutil/bytes_test.go
@@ -0,0 +1,14 @@
+package ethutil
+
+import (
+ "bytes"
+ "testing"
+)
+
+func TestParseData(t *testing.T) {
+ data := ParseData("hello", "world", "0x0106")
+ exp := "68656c6c6f000000000000000000000000000000000000000000000000000000776f726c640000000000000000000000000000000000000000000000000000000106000000000000000000000000000000000000000000000000000000000000"
+ if bytes.Compare(data, Hex2Bytes(exp)) != 0 {
+ t.Error("Error parsing data")
+ }
+}
diff --git a/ethutil/common.go b/ethutil/common.go
new file mode 100644
index 0000000000000000000000000000000000000000..8532d80f2c9809fb9619ce6673670db7518eb165
--- /dev/null
+++ b/ethutil/common.go
@@ -0,0 +1,85 @@
+package ethutil
+
+import (
+ "fmt"
+ "math/big"
+ "runtime"
+)
+
+func IsWindows() bool {
+ return runtime.GOOS == "windows"
+}
+
+func WindonizePath(path string) string {
+ if string(path[0]) == "/" && IsWindows() {
+ path = path[1:]
+ }
+ return path
+}
+
+// The different number of units
+var (
+ Douglas = BigPow(10, 42)
+ Einstein = BigPow(10, 21)
+ Ether = BigPow(10, 18)
+ Finney = BigPow(10, 15)
+ Szabo = BigPow(10, 12)
+ Shannon = BigPow(10, 9)
+ Babbage = BigPow(10, 6)
+ Ada = BigPow(10, 3)
+ Wei = big.NewInt(1)
+)
+
+//
+// Currency to string
+// Returns a string representing a human readable format
+func CurrencyToString(num *big.Int) string {
+ var (
+ fin *big.Int = num
+ denom string = "Wei"
+ )
+
+ switch {
+ case num.Cmp(Douglas) >= 0:
+ fin = new(big.Int).Div(num, Douglas)
+ denom = "Douglas"
+ case num.Cmp(Einstein) >= 0:
+ fin = new(big.Int).Div(num, Einstein)
+ denom = "Einstein"
+ case num.Cmp(Ether) >= 0:
+ fin = new(big.Int).Div(num, Ether)
+ denom = "Ether"
+ case num.Cmp(Finney) >= 0:
+ fin = new(big.Int).Div(num, Finney)
+ denom = "Finney"
+ case num.Cmp(Szabo) >= 0:
+ fin = new(big.Int).Div(num, Szabo)
+ denom = "Szabo"
+ case num.Cmp(Shannon) >= 0:
+ fin = new(big.Int).Div(num, Shannon)
+ denom = "Shannon"
+ case num.Cmp(Babbage) >= 0:
+ fin = new(big.Int).Div(num, Babbage)
+ denom = "Babbage"
+ case num.Cmp(Ada) >= 0:
+ fin = new(big.Int).Div(num, Ada)
+ denom = "Ada"
+ }
+
+ if len(fin.String()) > 5 {
+ return fmt.Sprintf("%sE%d %s", fin.String()[0:5], len(fin.String())-5, denom)
+ }
+
+ return fmt.Sprintf("%v %s", fin, denom)
+}
+
+// Common big integers often used
+var (
+ Big1 = big.NewInt(1)
+ Big2 = big.NewInt(2)
+ Big0 = big.NewInt(0)
+ BigTrue = Big1
+ BigFalse = Big0
+ Big32 = big.NewInt(32)
+ Big256 = big.NewInt(0xff)
+)
diff --git a/ethutil/common_test.go b/ethutil/common_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..2667eaf3afc222847332c919a483b1a040f7ed91
--- /dev/null
+++ b/ethutil/common_test.go
@@ -0,0 +1,44 @@
+package ethutil
+
+import (
+ "math/big"
+ "testing"
+)
+
+func TestCommon(t *testing.T) {
+ ether := CurrencyToString(BigPow(10, 19))
+ finney := CurrencyToString(BigPow(10, 16))
+ szabo := CurrencyToString(BigPow(10, 13))
+ vito := CurrencyToString(BigPow(10, 10))
+ turing := CurrencyToString(BigPow(10, 7))
+ eins := CurrencyToString(BigPow(10, 4))
+ wei := CurrencyToString(big.NewInt(10))
+
+ if ether != "10 Ether" {
+ t.Error("Got", ether)
+ }
+
+ if finney != "10 Finney" {
+ t.Error("Got", finney)
+ }
+
+ if szabo != "10 Szabo" {
+ t.Error("Got", szabo)
+ }
+
+ if vito != "10 Shannon" {
+ t.Error("Got", vito)
+ }
+
+ if turing != "10 Babbage" {
+ t.Error("Got", turing)
+ }
+
+ if eins != "10 Ada" {
+ t.Error("Got", eins)
+ }
+
+ if wei != "10 Wei" {
+ t.Error("Got", wei)
+ }
+}
diff --git a/ethutil/config.go b/ethutil/config.go
new file mode 100644
index 0000000000000000000000000000000000000000..ccc7714d01c1e1dd9ed546f3ff543fce7644e44b
--- /dev/null
+++ b/ethutil/config.go
@@ -0,0 +1,72 @@
+package ethutil
+
+import (
+ "flag"
+ "fmt"
+ "os"
+
+ "github.com/rakyll/globalconf"
+)
+
+// Config struct
+type ConfigManager struct {
+ Db Database
+
+ ExecPath string
+ Debug bool
+ Diff bool
+ DiffType string
+ Paranoia bool
+ VmType int
+
+ conf *globalconf.GlobalConf
+}
+
+var Config *ConfigManager
+
+// Read config
+//
+// Initialize Config from Config File
+func ReadConfig(ConfigFile string, Datadir string, EnvPrefix string) *ConfigManager {
+ if Config == nil {
+ // create ConfigFile if does not exist, otherwise globalconf panic when trying to persist flags
+ if !FileExist(ConfigFile) {
+ fmt.Printf("config file '%s' doesn't exist, creating it\n", ConfigFile)
+ os.Create(ConfigFile)
+ }
+ g, err := globalconf.NewWithOptions(&globalconf.Options{
+ Filename: ConfigFile,
+ EnvPrefix: EnvPrefix,
+ })
+ if err != nil {
+ fmt.Println(err)
+ } else {
+ g.ParseAll()
+ }
+ Config = &ConfigManager{ExecPath: Datadir, Debug: true, conf: g, Paranoia: true}
+ }
+ return Config
+}
+
+// provides persistence for flags
+func (c *ConfigManager) Save(key string, value interface{}) {
+ f := &flag.Flag{Name: key, Value: newConfValue(value)}
+ c.conf.Set("", f)
+}
+
+func (c *ConfigManager) Delete(key string) {
+ c.conf.Delete("", key)
+}
+
+// private type implementing flag.Value
+type confValue struct {
+ value string
+}
+
+// generic constructor to allow persising non-string values directly
+func newConfValue(value interface{}) *confValue {
+ return &confValue{fmt.Sprintf("%v", value)}
+}
+
+func (self confValue) String() string { return self.value }
+func (self confValue) Set(s string) error { self.value = s; return nil }
diff --git a/ethutil/db.go b/ethutil/db.go
new file mode 100644
index 0000000000000000000000000000000000000000..e02a80fca7e493bb07d1575cb8c14eae8c006b99
--- /dev/null
+++ b/ethutil/db.go
@@ -0,0 +1,12 @@
+package ethutil
+
+// Database interface
+type Database interface {
+ Put(key []byte, value []byte)
+ Get(key []byte) ([]byte, error)
+ //GetKeys() []*Key
+ Delete(key []byte) error
+ LastKnownTD() []byte
+ Close()
+ Print()
+}
diff --git a/ethutil/list.go b/ethutil/list.go
new file mode 100644
index 0000000000000000000000000000000000000000..6919a02f56d3ae0e444fa4d6992a9a282620b36e
--- /dev/null
+++ b/ethutil/list.go
@@ -0,0 +1,80 @@
+package ethutil
+
+import (
+ "encoding/json"
+ "reflect"
+ "sync"
+)
+
+// The list type is an anonymous slice handler which can be used
+// for containing any slice type to use in an environment which
+// does not support slice types (e.g., JavaScript, QML)
+type List struct {
+ mut sync.Mutex
+ val interface{}
+ list reflect.Value
+ Length int
+}
+
+// Initialise a new list. Panics if non-slice type is given.
+func NewList(t interface{}) *List {
+ list := reflect.ValueOf(t)
+ if list.Kind() != reflect.Slice {
+ panic("list container initialized with a non-slice type")
+ }
+
+ return &List{sync.Mutex{}, t, list, list.Len()}
+}
+
+func EmptyList() *List {
+ return NewList([]interface{}{})
+}
+
+// Get N element from the embedded slice. Returns nil if OOB.
+func (self *List) Get(i int) interface{} {
+ if self.list.Len() > i {
+ self.mut.Lock()
+ defer self.mut.Unlock()
+
+ i := self.list.Index(i).Interface()
+
+ return i
+ }
+
+ return nil
+}
+
+func (self *List) GetAsJson(i int) interface{} {
+ e := self.Get(i)
+
+ r, _ := json.Marshal(e)
+
+ return string(r)
+}
+
+// Appends value at the end of the slice. Panics when incompatible value
+// is given.
+func (self *List) Append(v interface{}) {
+ self.mut.Lock()
+ defer self.mut.Unlock()
+
+ self.list = reflect.Append(self.list, reflect.ValueOf(v))
+ self.Length = self.list.Len()
+}
+
+// Returns the underlying slice as interface.
+func (self *List) Interface() interface{} {
+ return self.list.Interface()
+}
+
+// For JavaScript <3
+func (self *List) ToJSON() string {
+ var list []interface{}
+ for i := 0; i < self.Length; i++ {
+ list = append(list, self.Get(i))
+ }
+
+ data, _ := json.Marshal(list)
+
+ return string(data)
+}
diff --git a/ethutil/package.go b/ethutil/package.go
new file mode 100644
index 0000000000000000000000000000000000000000..e5df989d234675f7b5d177a0714a61ce00381aee
--- /dev/null
+++ b/ethutil/package.go
@@ -0,0 +1,123 @@
+package ethutil
+
+import (
+ "archive/zip"
+ "encoding/json"
+ "fmt"
+ "io"
+ "io/ioutil"
+ "strings"
+)
+
+// Manifest object
+//
+// The manifest object holds all the relevant information supplied with the
+// the manifest specified in the package
+type Manifest struct {
+ Entry string
+ Height, Width int
+}
+
+// External package
+//
+// External package contains the main html file and manifest
+type ExtPackage struct {
+ EntryHtml string
+ Manifest *Manifest
+}
+
+// Read file
+//
+// Read a given compressed file and returns the read bytes.
+// Returns an error otherwise
+func ReadFile(f *zip.File) ([]byte, error) {
+ rc, err := f.Open()
+ if err != nil {
+ return nil, err
+ }
+ defer rc.Close()
+
+ content, err := ioutil.ReadAll(rc)
+ if err != nil {
+ return nil, err
+ }
+
+ return content, nil
+}
+
+// Reads manifest
+//
+// Reads and returns a manifest object. Returns error otherwise
+func ReadManifest(m []byte) (*Manifest, error) {
+ var manifest Manifest
+
+ dec := json.NewDecoder(strings.NewReader(string(m)))
+ if err := dec.Decode(&manifest); err == io.EOF {
+ } else if err != nil {
+ return nil, err
+ }
+
+ return &manifest, nil
+}
+
+// Find file in archive
+//
+// Returns the index of the given file name if it exists. -1 if file not found
+func FindFileInArchive(fn string, files []*zip.File) (index int) {
+ index = -1
+ // Find the manifest first
+ for i, f := range files {
+ if f.Name == fn {
+ index = i
+ }
+ }
+
+ return
+}
+
+// Open package
+//
+// Opens a prepared ethereum package
+// Reads the manifest file and determines file contents and returns and
+// the external package.
+func OpenPackage(fn string) (*ExtPackage, error) {
+ r, err := zip.OpenReader(fn)
+ if err != nil {
+ return nil, err
+ }
+ defer r.Close()
+
+ manifestIndex := FindFileInArchive("manifest.json", r.File)
+
+ if manifestIndex < 0 {
+ return nil, fmt.Errorf("No manifest file found in archive")
+ }
+
+ f, err := ReadFile(r.File[manifestIndex])
+ if err != nil {
+ return nil, err
+ }
+
+ manifest, err := ReadManifest(f)
+ if err != nil {
+ return nil, err
+ }
+
+ if manifest.Entry == "" {
+ return nil, fmt.Errorf("Entry file specified but appears to be empty: %s", manifest.Entry)
+ }
+
+ entryIndex := FindFileInArchive(manifest.Entry, r.File)
+ if entryIndex < 0 {
+ return nil, fmt.Errorf("Entry file not found: '%s'", manifest.Entry)
+ }
+
+ f, err = ReadFile(r.File[entryIndex])
+ if err != nil {
+ return nil, err
+ }
+
+ extPackage := &ExtPackage{string(f), manifest}
+
+ return extPackage, nil
+}
diff --git a/ethutil/path.go b/ethutil/path.go
new file mode 100644
index 0000000000000000000000000000000000000000..cfbc389508cc1517da208e0844db064fcc51206a
--- /dev/null
+++ b/ethutil/path.go
@@ -0,0 +1,60 @@
+package ethutil
+
+import (
+ "io/ioutil"
+ "os"
+ "os/user"
+ "strings"
+)
+
+func ExpandHomePath(p string) (path string) {
+ path = p
+
+ // Check in case of paths like "/something/~/something/"
+ if path[:2] == "~/" {
+ usr, _ := user.Current()
+ dir := usr.HomeDir
+
+ path = strings.Replace(p, "~", dir, 1)
+ }
+
+ return
+}
+
+func FileExist(filePath string) bool {
+ _, err := os.Stat(filePath)
+ if err != nil && os.IsNotExist(err) {
+ return false
+ }
+
+ return true
+}
+
+func ReadAllFile(filePath string) (string, error) {
+ file, err := os.Open(filePath)
+ if err != nil {
+ return "", err
+ }
+
+ data, err := ioutil.ReadAll(file)
+ if err != nil {
+ return "", err
+ }
+
+ return string(data), nil
+}
+
+func WriteFile(filePath string, content []byte) error {
+ fh, err := os.OpenFile(filePath, os.O_TRUNC|os.O_RDWR|os.O_CREATE, os.ModePerm)
+ if err != nil {
+ return err
+ }
+ defer fh.Close()
+
+ _, err = fh.Write(content)
+ if err != nil {
+ return err
+ }
+
+ return nil
+}
diff --git a/ethutil/rand.go b/ethutil/rand.go
new file mode 100644
index 0000000000000000000000000000000000000000..91dafec7ed6f960c5c731ac215bc4c09dcfb88e1
--- /dev/null
+++ b/ethutil/rand.go
@@ -0,0 +1,24 @@
+package ethutil
+
+import (
+ "crypto/rand"
+ "encoding/binary"
+ "io"
+)
+
+func randomUint64(r io.Reader) (uint64, error) {
+ b := make([]byte, 8)
+ n, err := r.Read(b)
+ if n != len(b) {
+ return 0, io.ErrShortBuffer
+ }
+ if err != nil {
+ return 0, err
+ }
+ return binary.BigEndian.Uint64(b), nil
+}
+
+// RandomUint64 returns a cryptographically random uint64 value.
+func RandomUint64() (uint64, error) {
+ return randomUint64(rand.Reader)
+}
diff --git a/ethutil/rlp.go b/ethutil/rlp.go
new file mode 100644
index 0000000000000000000000000000000000000000..55406133b193273f09186431f9cb51908710a41f
--- /dev/null
+++ b/ethutil/rlp.go
@@ -0,0 +1,236 @@
+package ethutil
+
+import (
+ "bytes"
+ "fmt"
+ "math/big"
+)
+
+type RlpEncode interface {
+ RlpEncode() []byte
+}
+
+type RlpEncodeDecode interface {
+ RlpEncode
+ RlpValue() []interface{}
+}
+
+func Rlp(encoder RlpEncode) []byte {
+ return encoder.RlpEncode()
+}
+
+type RlpEncoder struct {
+ rlpData []byte
+}
+
+func NewRlpEncoder() *RlpEncoder {
+ encoder := &RlpEncoder{}
+
+ return encoder
+}
+func (coder *RlpEncoder) EncodeData(rlpData interface{}) []byte {
+ return Encode(rlpData)
+}
+
+const (
+ RlpEmptyList = 0x80
+ RlpEmptyStr = 0x40
+)
+
+const rlpEof = -1
+
+func Char(c []byte) int {
+ if len(c) > 0 {
+ return int(c[0])
+ }
+
+ return rlpEof
+}
+
+func DecodeWithReader(reader *bytes.Buffer) interface{} {
+ var slice []interface{}
+
+ // Read the next byte
+ char := Char(reader.Next(1))
+ switch {
+ case char <= 0x7f:
+ return char
+
+ case char <= 0xb7:
+ return reader.Next(int(char - 0x80))
+
+ case char <= 0xbf:
+ length := ReadVarInt(reader.Next(int(char - 0xb7)))
+
+ return reader.Next(int(length))
+
+ case char <= 0xf7:
+ length := int(char - 0xc0)
+ for i := 0; i < length; i++ {
+ obj := DecodeWithReader(reader)
+ slice = append(slice, obj)
+ }
+
+ return slice
+ case char <= 0xff:
+ length := ReadVarInt(reader.Next(int(char - 0xf7)))
+ for i := uint64(0); i < length; i++ {
+ obj := DecodeWithReader(reader)
+ slice = append(slice, obj)
+ }
+
+ return slice
+ default:
+ panic(fmt.Sprintf("byte not supported: %q", char))
+ }
+
+ return slice
+}
+
+var (
+ directRlp = big.NewInt(0x7f)
+ numberRlp = big.NewInt(0xb7)
+ zeroRlp = big.NewInt(0x0)
+)
+
+func Encode(object interface{}) []byte {
+ var buff bytes.Buffer
+
+ if object != nil {
+ switch t := object.(type) {
+ case *Value:
+ buff.Write(Encode(t.Raw()))
+ // Code dup :-/
+ case int:
+ buff.Write(Encode(big.NewInt(int64(t))))
+ case uint:
+ buff.Write(Encode(big.NewInt(int64(t))))
+ case int8:
+ buff.Write(Encode(big.NewInt(int64(t))))
+ case int16:
+ buff.Write(Encode(big.NewInt(int64(t))))
+ case int32:
+ buff.Write(Encode(big.NewInt(int64(t))))
+ case int64:
+ buff.Write(Encode(big.NewInt(t)))
+ case uint16:
+ buff.Write(Encode(big.NewInt(int64(t))))
+ case uint32:
+ buff.Write(Encode(big.NewInt(int64(t))))
+ case uint64:
+ buff.Write(Encode(big.NewInt(int64(t))))
+ case byte:
+ buff.Write(Encode(big.NewInt(int64(t))))
+ case *big.Int:
+ // Not sure how this is possible while we check for
+ if t == nil {
+ buff.WriteByte(0xc0)
+ } else {
+ buff.Write(Encode(t.Bytes()))
+ }
+ case Bytes:
+ buff.Write(Encode([]byte(t)))
+ case []byte:
+ if len(t) == 1 && t[0] <= 0x7f {
+ buff.Write(t)
+ } else if len(t) < 56 {
+ buff.WriteByte(byte(len(t) + 0x80))
+ buff.Write(t)
+ } else {
+ b := big.NewInt(int64(len(t)))
+ buff.WriteByte(byte(len(b.Bytes()) + 0xb7))
+ buff.Write(b.Bytes())
+ buff.Write(t)
+ }
+ case string:
+ buff.Write(Encode([]byte(t)))
+ case []interface{}:
+ // Inline function for writing the slice header
+ WriteSliceHeader := func(length int) {
+ if length < 56 {
+ buff.WriteByte(byte(length + 0xc0))
+ } else {
+ b := big.NewInt(int64(length))
+ buff.WriteByte(byte(len(b.Bytes()) + 0xf7))
+ buff.Write(b.Bytes())
+ }
+ }
+
+ var b bytes.Buffer
+ for _, val := range t {
+ b.Write(Encode(val))
+ }
+ WriteSliceHeader(len(b.Bytes()))
+ buff.Write(b.Bytes())
+ }
+ } else {
+ // Empty list for nil
+ buff.WriteByte(0xc0)
+ }
+
+ return buff.Bytes()
+}
+
+// TODO Use a bytes.Buffer instead of a raw byte slice.
+// Cleaner code, and use draining instead of seeking the next bytes to read
+func Decode(data []byte, pos uint64) (interface{}, uint64) {
+ var slice []interface{}
+ char := int(data[pos])
+ switch {
+ case char <= 0x7f:
+ return data[pos], pos + 1
+
+ case char <= 0xb7:
+ b := uint64(data[pos]) - 0x80
+
+ return data[pos+1 : pos+1+b], pos + 1 + b
+
+ case char <= 0xbf:
+ b := uint64(data[pos]) - 0xb7
+
+ b2 := ReadVarInt(data[pos+1 : pos+1+b])
+
+ return data[pos+1+b : pos+1+b+b2], pos + 1 + b + b2
+
+ case char <= 0xf7:
+ b := uint64(data[pos]) - 0xc0
+ prevPos := pos
+ pos++
+ for i := uint64(0); i < b; {
+ var obj interface{}
+
+ // Get the next item in the data list and append it
+ obj, prevPos = Decode(data, pos)
+ slice = append(slice, obj)
+
+ // Increment i by the amount bytes read in the previous
+ // read
+ i += (prevPos - pos)
+ pos = prevPos
+ }
+ return slice, pos
+
+ case char <= 0xff:
+ l := uint64(data[pos]) - 0xf7
+ b := ReadVarInt(data[pos+1 : pos+1+l])
+
+ pos = pos + l + 1
+
+ prevPos := b
+ for i := uint64(0); i < uint64(b); {
+ var obj interface{}
+
+ obj, prevPos = Decode(data, pos)
+ slice = append(slice, obj)
+
+ i += (prevPos - pos)
+ pos = prevPos
+ }
+ return slice, pos
+
+ default:
+ panic(fmt.Sprintf("byte not supported: %q", char))
+ }
+
+ return slice, 0
+}
diff --git a/ethutil/rlp_test.go b/ethutil/rlp_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..90057ab42d5f3b32db47ebde8c01eb427872f09d
--- /dev/null
+++ b/ethutil/rlp_test.go
@@ -0,0 +1,146 @@
+package ethutil
+
+import (
+ "bytes"
+ "math/big"
+ "reflect"
+ "testing"
+)
+
+func TestRlpValueEncoding(t *testing.T) {
+ val := EmptyValue()
+ val.AppendList().Append(1).Append(2).Append(3)
+ val.Append("4").AppendList().Append(5)
+
+ res := val.Encode()
+ exp := Encode([]interface{}{[]interface{}{1, 2, 3}, "4", []interface{}{5}})
+ if bytes.Compare(res, exp) != 0 {
+ t.Errorf("expected %q, got %q", res, exp)
+ }
+}
+
+func TestValueSlice(t *testing.T) {
+ val := []interface{}{
+ "value1",
+ "valeu2",
+ "value3",
+ }
+
+ value := NewValue(val)
+ splitVal := value.SliceFrom(1)
+
+ if splitVal.Len() != 2 {
+ t.Error("SliceFrom: Expected len", 2, "got", splitVal.Len())
+ }
+
+ splitVal = value.SliceTo(2)
+ if splitVal.Len() != 2 {
+ t.Error("SliceTo: Expected len", 2, "got", splitVal.Len())
+ }
+
+ splitVal = value.SliceFromTo(1, 3)
+ if splitVal.Len() != 2 {
+ t.Error("SliceFromTo: Expected len", 2, "got", splitVal.Len())
+ }
+}
+
+func TestLargeData(t *testing.T) {
+ data := make([]byte, 100000)
+ enc := Encode(data)
+ value := NewValue(enc)
+ value.Decode()
+
+ if value.Len() != len(data) {
+ t.Error("Expected data to be", len(data), "got", value.Len())
+ }
+}
+
+func TestValue(t *testing.T) {
+ value := NewValueFromBytes([]byte("\xcd\x83dog\x83god\x83cat\x01"))
+ if value.Get(0).Str() != "dog" {
+ t.Errorf("expected '%v', got '%v'", value.Get(0).Str(), "dog")
+ }
+
+ if value.Get(3).Uint() != 1 {
+ t.Errorf("expected '%v', got '%v'", value.Get(3).Uint(), 1)
+ }
+}
+
+func TestEncode(t *testing.T) {
+ strRes := "\x83dog"
+ bytes := Encode("dog")
+
+ str := string(bytes)
+ if str != strRes {
+ t.Errorf("Expected %q, got %q", strRes, str)
+ }
+
+ sliceRes := "\xcc\x83dog\x83god\x83cat"
+ strs := []interface{}{"dog", "god", "cat"}
+ bytes = Encode(strs)
+ slice := string(bytes)
+ if slice != sliceRes {
+ t.Error("Expected %q, got %q", sliceRes, slice)
+ }
+
+ intRes := "\x82\x04\x00"
+ bytes = Encode(1024)
+ if string(bytes) != intRes {
+ t.Errorf("Expected %q, got %q", intRes, bytes)
+ }
+}
+
+func TestDecode(t *testing.T) {
+ single := []byte("\x01")
+ b, _ := Decode(single, 0)
+
+ if b.(uint8) != 1 {
+ t.Errorf("Expected 1, got %q", b)
+ }
+
+ str := []byte("\x83dog")
+ b, _ = Decode(str, 0)
+ if bytes.Compare(b.([]byte), []byte("dog")) != 0 {
+ t.Errorf("Expected dog, got %q", b)
+ }
+
+ slice := []byte("\xcc\x83dog\x83god\x83cat")
+ res := []interface{}{"dog", "god", "cat"}
+ b, _ = Decode(slice, 0)
+ if reflect.DeepEqual(b, res) {
+ t.Errorf("Expected %q, got %q", res, b)
+ }
+}
+
+func TestEncodeDecodeBigInt(t *testing.T) {
+ bigInt := big.NewInt(1391787038)
+ encoded := Encode(bigInt)
+
+ value := NewValueFromBytes(encoded)
+ if value.BigInt().Cmp(bigInt) != 0 {
+ t.Errorf("Expected %v, got %v", bigInt, value.BigInt())
+ }
+}
+
+func TestEncodeDecodeBytes(t *testing.T) {
+ b := NewValue([]interface{}{[]byte{1, 2, 3, 4, 5}, byte(6)})
+ val := NewValueFromBytes(b.Encode())
+ if !b.Cmp(val) {
+ t.Errorf("Expected %v, got %v", val, b)
+ }
+}
+
+func TestEncodeZero(t *testing.T) {
+ b := NewValue(0).Encode()
+ exp := []byte{0xc0}
+ if bytes.Compare(b, exp) == 0 {
+ t.Error("Expected", exp, "got", b)
+ }
+}
+
+func BenchmarkEncodeDecode(b *testing.B) {
+ for i := 0; i < b.N; i++ {
+ bytes := Encode([]interface{}{"dog", "god", "cat"})
+ Decode(bytes, 0)
+ }
+}
diff --git a/ethutil/script_unix.go b/ethutil/script_unix.go
new file mode 100644
index 0000000000000000000000000000000000000000..bd087e7e0434b5a6d3db749f3e8fb4acf0e6211e
--- /dev/null
+++ b/ethutil/script_unix.go
@@ -0,0 +1,47 @@
+package ethutil
+
+import (
+ "fmt"
+ "strings"
+
+ "github.com/obscuren/mutan"
+ "github.com/obscuren/mutan/backends"
+ "github.com/obscuren/serpent-go"
+)
+
+// General compile function
+func Compile(script string, silent bool) (ret []byte, err error) {
+ if len(script) > 2 {
+ line := strings.Split(script, "\n")[0]
+
+ if len(line) > 1 && line[0:2] == "#!" {
+ switch line {
+ case "#!serpent":
+ byteCode, err := serpent.Compile(script)
+ if err != nil {
+ return nil, err
+ }
+
+ return byteCode, nil
+ }
+ } else {
+
+ compiler := mutan.NewCompiler(backend.NewEthereumBackend())
+ compiler.Silent = silent
+ byteCode, errors := compiler.Compile(strings.NewReader(script))
+ if len(errors) > 0 {
+ var errs string
+ for _, er := range errors {
+ if er != nil {
+ errs += er.Error()
+ }
+ }
+ return nil, fmt.Errorf("%v", errs)
+ }
+
+ return byteCode, nil
+ }
+ }
+
+ return nil, nil
+}
diff --git a/ethutil/script_windows.go b/ethutil/script_windows.go
new file mode 100644
index 0000000000000000000000000000000000000000..4f94c6448aed03d759086b59812019fa74223571
--- /dev/null
+++ b/ethutil/script_windows.go
@@ -0,0 +1,31 @@
+package ethutil
+
+import (
+ "fmt"
+ "strings"
+
+ "github.com/obscuren/mutan"
+ "github.com/obscuren/mutan/backends"
+)
+
+// General compile function
+func Compile(script string, silent bool) (ret []byte, err error) {
+ if len(script) > 2 {
+ compiler := mutan.NewCompiler(backend.NewEthereumBackend())
+ compiler.Silent = silent
+ byteCode, errors := compiler.Compile(strings.NewReader(script))
+ if len(errors) > 0 {
+ var errs string
+ for _, er := range errors {
+ if er != nil {
+ errs += er.Error()
+ }
+ }
+ return nil, fmt.Errorf("%v", errs)
+ }
+
+ return byteCode, nil
+ }
+
+ return nil, nil
+}
diff --git a/ethutil/set.go b/ethutil/set.go
new file mode 100644
index 0000000000000000000000000000000000000000..7955edac071a16c16eec4c7edd747eb85d7d3ee3
--- /dev/null
+++ b/ethutil/set.go
@@ -0,0 +1,36 @@
+package ethutil
+
+type Settable interface {
+ AsSet() UniqueSet
+}
+
+type Stringable interface {
+ String() string
+}
+
+type UniqueSet map[string]struct{}
+
+func NewSet(v ...Stringable) UniqueSet {
+ set := make(UniqueSet)
+ for _, val := range v {
+ set.Insert(val)
+ }
+
+ return set
+}
+
+func (self UniqueSet) Insert(k Stringable) UniqueSet {
+ self[k.String()] = struct{}{}
+
+ return self
+}
+
+func (self UniqueSet) Include(k Stringable) bool {
+ _, ok := self[k.String()]
+
+ return ok
+}
+
+func Set(s Settable) UniqueSet {
+ return s.AsSet()
+}
diff --git a/ethutil/size.go b/ethutil/size.go
new file mode 100644
index 0000000000000000000000000000000000000000..b4426465e6139dcf558a2999f8130260f46530a5
--- /dev/null
+++ b/ethutil/size.go
@@ -0,0 +1,15 @@
+package ethutil
+
+import "fmt"
+
+type StorageSize float64
+
+func (self StorageSize) String() string {
+ if self > 1000000 {
+ return fmt.Sprintf("%.2f mB", self/1000000)
+ } else if self > 1000 {
+ return fmt.Sprintf("%.2f kB", self/1000)
+ } else {
+ return fmt.Sprintf("%.2f B", self)
+ }
+}
diff --git a/ethutil/size_test.go b/ethutil/size_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..82aa1c65335fd48534f84bcf6d2c40e11498f4c4
--- /dev/null
+++ b/ethutil/size_test.go
@@ -0,0 +1,12 @@
+package ethutil
+
+import (
+ "fmt"
+ "testing"
+)
+
+func TestSize(t *testing.T) {
+ fmt.Println(StorageSize(2381273))
+ fmt.Println(StorageSize(2192))
+ fmt.Println(StorageSize(12))
+}
diff --git a/ethutil/value.go b/ethutil/value.go
new file mode 100644
index 0000000000000000000000000000000000000000..dd777fa435e1c571253958d27e1735a64a2aa1dd
--- /dev/null
+++ b/ethutil/value.go
@@ -0,0 +1,397 @@
+package ethutil
+
+import (
+ "bytes"
+ "fmt"
+ "math/big"
+ "reflect"
+ "strconv"
+)
+
+// Data values are returned by the rlp decoder. The data values represents
+// one item within the rlp data structure. It's responsible for all the casting
+// It always returns something valid
+type Value struct {
+ Val interface{}
+ kind reflect.Value
+}
+
+func (val *Value) String() string {
+ return fmt.Sprintf("%x", val.Val)
+}
+
+func NewValue(val interface{}) *Value {
+ t := val
+ if v, ok := val.(*Value); ok {
+ t = v.Val
+ }
+
+ return &Value{Val: t}
+}
+
+func (val *Value) Type() reflect.Kind {
+ return reflect.TypeOf(val.Val).Kind()
+}
+
+func (val *Value) IsNil() bool {
+ return val.Val == nil
+}
+
+func (val *Value) Len() int {
+ //return val.kind.Len()
+ if data, ok := val.Val.([]interface{}); ok {
+ return len(data)
+ }
+
+ return len(val.Bytes())
+}
+
+func (val *Value) Raw() interface{} {
+ return val.Val
+}
+
+func (val *Value) Interface() interface{} {
+ return val.Val
+}
+
+func (val *Value) Uint() uint64 {
+ if Val, ok := val.Val.(uint8); ok {
+ return uint64(Val)
+ } else if Val, ok := val.Val.(uint16); ok {
+ return uint64(Val)
+ } else if Val, ok := val.Val.(uint32); ok {
+ return uint64(Val)
+ } else if Val, ok := val.Val.(uint64); ok {
+ return Val
+ } else if Val, ok := val.Val.(float32); ok {
+ return uint64(Val)
+ } else if Val, ok := val.Val.(float64); ok {
+ return uint64(Val)
+ } else if Val, ok := val.Val.(int); ok {
+ return uint64(Val)
+ } else if Val, ok := val.Val.(uint); ok {
+ return uint64(Val)
+ } else if Val, ok := val.Val.([]byte); ok {
+ return new(big.Int).SetBytes(Val).Uint64()
+ } else if Val, ok := val.Val.(*big.Int); ok {
+ return Val.Uint64()
+ }
+
+ return 0
+}
+
+func (val *Value) Int() int64 {
+ if Val, ok := val.Val.(int8); ok {
+ return int64(Val)
+ } else if Val, ok := val.Val.(int16); ok {
+ return int64(Val)
+ } else if Val, ok := val.Val.(int32); ok {
+ return int64(Val)
+ } else if Val, ok := val.Val.(int64); ok {
+ return Val
+ } else if Val, ok := val.Val.(int); ok {
+ return int64(Val)
+ } else if Val, ok := val.Val.(float32); ok {
+ return int64(Val)
+ } else if Val, ok := val.Val.(float64); ok {
+ return int64(Val)
+ } else if Val, ok := val.Val.([]byte); ok {
+ return new(big.Int).SetBytes(Val).Int64()
+ } else if Val, ok := val.Val.(*big.Int); ok {
+ return Val.Int64()
+ } else if Val, ok := val.Val.(string); ok {
+ n, _ := strconv.Atoi(Val)
+ return int64(n)
+ }
+
+ return 0
+}
+
+func (val *Value) Byte() byte {
+ if Val, ok := val.Val.(byte); ok {
+ return Val
+ }
+
+ return 0x0
+}
+
+func (val *Value) BigInt() *big.Int {
+ if a, ok := val.Val.([]byte); ok {
+ b := new(big.Int).SetBytes(a)
+
+ return b
+ } else if a, ok := val.Val.(*big.Int); ok {
+ return a
+ } else if a, ok := val.Val.(string); ok {
+ return Big(a)
+ } else {
+ return big.NewInt(int64(val.Uint()))
+ }
+
+ return big.NewInt(0)
+}
+
+func (val *Value) Str() string {
+ if a, ok := val.Val.([]byte); ok {
+ return string(a)
+ } else if a, ok := val.Val.(string); ok {
+ return a
+ } else if a, ok := val.Val.(byte); ok {
+ return string(a)
+ }
+
+ return ""
+}
+
+func (val *Value) Bytes() []byte {
+ if a, ok := val.Val.([]byte); ok {
+ return a
+ } else if s, ok := val.Val.(byte); ok {
+ return []byte{s}
+ } else if s, ok := val.Val.(string); ok {
+ return []byte(s)
+ } else if s, ok := val.Val.(*big.Int); ok {
+ return s.Bytes()
+ } else {
+ return big.NewInt(val.Int()).Bytes()
+ }
+
+ return []byte{}
+}
+
+func (val *Value) Err() error {
+ if err, ok := val.Val.(error); ok {
+ return err
+ }
+
+ return nil
+}
+
+func (val *Value) Slice() []interface{} {
+ if d, ok := val.Val.([]interface{}); ok {
+ return d
+ }
+
+ return []interface{}{}
+}
+
+func (val *Value) SliceFrom(from int) *Value {
+ slice := val.Slice()
+
+ return NewValue(slice[from:])
+}
+
+func (val *Value) SliceTo(to int) *Value {
+ slice := val.Slice()
+
+ return NewValue(slice[:to])
+}
+
+func (val *Value) SliceFromTo(from, to int) *Value {
+ slice := val.Slice()
+
+ return NewValue(slice[from:to])
+}
+
+// TODO More type checking methods
+func (val *Value) IsSlice() bool {
+ return val.Type() == reflect.Slice
+}
+
+func (val *Value) IsStr() bool {
+ return val.Type() == reflect.String
+}
+
+func (self *Value) IsErr() bool {
+ _, ok := self.Val.(error)
+ return ok
+}
+
+// Special list checking function. Something is considered
+// a list if it's of type []interface{}. The list is usually
+// used in conjunction with rlp decoded streams.
+func (val *Value) IsList() bool {
+ _, ok := val.Val.([]interface{})
+
+ return ok
+}
+
+func (val *Value) IsEmpty() bool {
+ return val.Val == nil || ((val.IsSlice() || val.IsStr()) && val.Len() == 0)
+}
+
+// Threat the value as a slice
+func (val *Value) Get(idx int) *Value {
+ if d, ok := val.Val.([]interface{}); ok {
+ // Guard for oob
+ if len(d) <= idx {
+ return NewValue(nil)
+ }
+
+ if idx < 0 {
+ return NewValue(nil)
+ }
+
+ return NewValue(d[idx])
+ }
+
+ // If this wasn't a slice you probably shouldn't be using this function
+ return NewValue(nil)
+}
+
+func (self *Value) Copy() *Value {
+ switch val := self.Val.(type) {
+ case *big.Int:
+ return NewValue(new(big.Int).Set(val))
+ case []byte:
+ return NewValue(CopyBytes(val))
+ default:
+ return NewValue(self.Val)
+ }
+
+ return nil
+}
+
+func (val *Value) Cmp(o *Value) bool {
+ return reflect.DeepEqual(val.Val, o.Val)
+}
+
+func (self *Value) DeepCmp(o *Value) bool {
+ return bytes.Compare(self.Bytes(), o.Bytes()) == 0
+}
+
+func (val *Value) Encode() []byte {
+ return Encode(val.Val)
+}
+
+// Assume that the data we have is encoded
+func (self *Value) Decode() {
+ v, _ := Decode(self.Bytes(), 0)
+ self.Val = v
+ //self.Val = DecodeWithReader(bytes.NewBuffer(self.Bytes()))
+}
+
+func NewValueFromBytes(data []byte) *Value {
+ if len(data) != 0 {
+ value := NewValue(data)
+ value.Decode()
+
+ return value
+ }
+
+ return NewValue(nil)
+}
+
+// Value setters
+func NewSliceValue(s interface{}) *Value {
+ list := EmptyValue()
+
+ if s != nil {
+ if slice, ok := s.([]interface{}); ok {
+ for _, val := range slice {
+ list.Append(val)
+ }
+ } else if slice, ok := s.([]string); ok {
+ for _, val := range slice {
+ list.Append(val)
+ }
+ }
+ }
+
+ return list
+}
+
+func EmptyValue() *Value {
+ return NewValue([]interface{}{})
+}
+
+func (val *Value) AppendList() *Value {
+ list := EmptyValue()
+ val.Val = append(val.Slice(), list)
+
+ return list
+}
+
+func (val *Value) Append(v interface{}) *Value {
+ val.Val = append(val.Slice(), v)
+
+ return val
+}
+
+const (
+ valOpAdd = iota
+ valOpDiv
+ valOpMul
+ valOpPow
+ valOpSub
+)
+
+// Math stuff
+func (self *Value) doOp(op int, other interface{}) *Value {
+ left := self.BigInt()
+ right := NewValue(other).BigInt()
+
+ switch op {
+ case valOpAdd:
+ self.Val = left.Add(left, right)
+ case valOpDiv:
+ self.Val = left.Div(left, right)
+ case valOpMul:
+ self.Val = left.Mul(left, right)
+ case valOpPow:
+ self.Val = left.Exp(left, right, Big0)
+ case valOpSub:
+ self.Val = left.Sub(left, right)
+ }
+
+ return self
+}
+
+func (self *Value) Add(other interface{}) *Value {
+ return self.doOp(valOpAdd, other)
+}
+
+func (self *Value) Sub(other interface{}) *Value {
+ return self.doOp(valOpSub, other)
+}
+
+func (self *Value) Div(other interface{}) *Value {
+ return self.doOp(valOpDiv, other)
+}
+
+func (self *Value) Mul(other interface{}) *Value {
+ return self.doOp(valOpMul, other)
+}
+
+func (self *Value) Pow(other interface{}) *Value {
+ return self.doOp(valOpPow, other)
+}
+
+type ValueIterator struct {
+ value *Value
+ currentValue *Value
+ idx int
+}
+
+func (val *Value) NewIterator() *ValueIterator {
+ return &ValueIterator{value: val}
+}
+
+func (it *ValueIterator) Next() bool {
+ if it.idx >= it.value.Len() {
+ return false
+ }
+
+ it.currentValue = it.value.Get(it.idx)
+ it.idx++
+
+ return true
+}
+
+func (it *ValueIterator) Value() *Value {
+ return it.currentValue
+}
+
+func (it *ValueIterator) Idx() int {
+ return it.idx
+}
diff --git a/ethutil/value_test.go b/ethutil/value_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..5452a0790c2b5b24bcd53c0b15bb077bbb0b69bd
--- /dev/null
+++ b/ethutil/value_test.go
@@ -0,0 +1,86 @@
+package ethutil
+
+import (
+ "bytes"
+ "fmt"
+ "math/big"
+ "testing"
+)
+
+func TestValueCmp(t *testing.T) {
+ val1 := NewValue("hello")
+ val2 := NewValue("world")
+ if val1.Cmp(val2) {
+ t.Error("Expected values not to be equal")
+ }
+
+ val3 := NewValue("hello")
+ val4 := NewValue("hello")
+ if !val3.Cmp(val4) {
+ t.Error("Expected values to be equal")
+ }
+}
+
+func TestValueTypes(t *testing.T) {
+ str := NewValue("str")
+ num := NewValue(1)
+ inter := NewValue([]interface{}{1})
+ byt := NewValue([]byte{1, 2, 3, 4})
+ bigInt := NewValue(big.NewInt(10))
+
+ if str.Str() != "str" {
+ t.Errorf("expected Str to return 'str', got %s", str.Str())
+ }
+
+ if num.Uint() != 1 {
+ t.Errorf("expected Uint to return '1', got %d", num.Uint())
+ }
+
+ interExp := []interface{}{1}
+ if !NewValue(inter.Interface()).Cmp(NewValue(interExp)) {
+ t.Errorf("expected Interface to return '%v', got %v", interExp, num.Interface())
+ }
+
+ bytExp := []byte{1, 2, 3, 4}
+ if bytes.Compare(byt.Bytes(), bytExp) != 0 {
+ t.Errorf("expected Bytes to return '%v', got %v", bytExp, byt.Bytes())
+ }
+
+ bigExp := big.NewInt(10)
+ if bigInt.BigInt().Cmp(bigExp) != 0 {
+ t.Errorf("expected BigInt to return '%v', got %v", bigExp, bigInt.BigInt())
+ }
+}
+
+func TestIterator(t *testing.T) {
+ value := NewValue([]interface{}{1, 2, 3})
+ it := value.NewIterator()
+ values := []uint64{1, 2, 3}
+ i := 0
+ for it.Next() {
+ if values[i] != it.Value().Uint() {
+ t.Errorf("Expected %d, got %d", values[i], it.Value().Uint())
+ }
+ i++
+ }
+}
+
+func TestMath(t *testing.T) {
+ a := NewValue(1)
+ a.Add(1).Add(1)
+
+ if !a.DeepCmp(NewValue(3)) {
+ t.Error("Expected 3, got", a)
+ }
+
+ a = NewValue(2)
+ a.Sub(1).Sub(1)
+ if !a.DeepCmp(NewValue(0)) {
+ t.Error("Expected 0, got", a)
+ }
+}
+
+func TestString(t *testing.T) {
+ a := NewValue("10")
+ fmt.Println("VALUE WITH STRING:", a.Int())
+}
diff --git a/ethwire/.gitignore b/ethwire/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..f725d58d14f7d1b6a8c41c45f78b4f38f529ae9e
--- /dev/null
+++ b/ethwire/.gitignore
@@ -0,0 +1,12 @@
+# See http://help.github.com/ignore-files/ for more about ignoring files.
+#
+# If you find yourself ignoring temporary files generated by your text editor
+# or operating system, you probably want to add a global ignore instead:
+# git config --global core.excludesfile ~/.gitignore_global
+
+/tmp
+*/**/*un~
+*un~
+.DS_Store
+*/**/.DS_Store
+
diff --git a/ethwire/README.md b/ethwire/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..7f63688b3cfe2e083c1eeeb4a3096975442c94c1
--- /dev/null
+++ b/ethwire/README.md
@@ -0,0 +1,36 @@
+# ethwire
+
+The ethwire package contains the ethereum wire protocol. The ethwire
+package is required to write and read from the ethereum network.
+
+# Installation
+
+`go get github.com/ethereum/ethwire-go`
+
+# Messaging overview
+
+The Ethereum Wire protocol defines the communication between the nodes
+running Ethereum. Further reader reading can be done on the
+[Wiki](http://wiki.ethereum.org/index.php/Wire_Protocol).
+
+# Reading Messages
+
+```go
+// Read and validate the next eth message from the provided connection.
+// returns a error message with the details.
+msg, err := ethwire.ReadMessage(conn)
+if err != nil {
+ // Handle error
+}
+```
+
+# Writing Messages
+
+```go
+// Constructs a message which can be interpreted by the eth network.
+// Write the inventory to network
+err := ethwire.WriteMessage(conn, &Msg{
+ Type: ethwire.MsgInvTy,
+ Data : []interface{}{...},
+})
+```
diff --git a/ethwire/client_identity.go b/ethwire/client_identity.go
new file mode 100644
index 0000000000000000000000000000000000000000..ceaa9fe83d2aa17049be076bf0da416e107c899f
--- /dev/null
+++ b/ethwire/client_identity.go
@@ -0,0 +1,56 @@
+package ethwire
+
+import (
+ "fmt"
+ "runtime"
+)
+
+// should be used in Peer handleHandshake, incorporate Caps, ProtocolVersion, Pubkey etc.
+type ClientIdentity interface {
+ String() string
+}
+
+type SimpleClientIdentity struct {
+ clientIdentifier string
+ version string
+ customIdentifier string
+ os string
+ implementation string
+}
+
+func NewSimpleClientIdentity(clientIdentifier string, version string, customIdentifier string) *SimpleClientIdentity {
+ clientIdentity := &SimpleClientIdentity{
+ clientIdentifier: clientIdentifier,
+ version: version,
+ customIdentifier: customIdentifier,
+ os: runtime.GOOS,
+ implementation: runtime.Version(),
+ }
+
+ return clientIdentity
+}
+
+func (c *SimpleClientIdentity) init() {
+}
+
+func (c *SimpleClientIdentity) String() string {
+ var id string
+ if len(c.customIdentifier) > 0 {
+ id = "/" + c.customIdentifier
+ }
+
+ return fmt.Sprintf("%s/v%s%s/%s/%s",
+ c.clientIdentifier,
+ c.version,
+ id,
+ c.os,
+ c.implementation)
+}
+
+func (c *SimpleClientIdentity) SetCustomIdentifier(customIdentifier string) {
+ c.customIdentifier = customIdentifier
+}
+
+func (c *SimpleClientIdentity) GetCustomIdentifier() string {
+ return c.customIdentifier
+}
diff --git a/ethwire/client_identity_test.go b/ethwire/client_identity_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..f3c8bfd50a3404ade734783879ecc329e78e4d0e
--- /dev/null
+++ b/ethwire/client_identity_test.go
@@ -0,0 +1,30 @@
+package ethwire
+
+import (
+ "fmt"
+ "runtime"
+ "testing"
+)
+
+func TestClientIdentity(t *testing.T) {
+ clientIdentity := NewSimpleClientIdentity("Ethereum(G)", "0.5.16", "test")
+ clientString := clientIdentity.String()
+ expected := fmt.Sprintf("Ethereum(G)/v0.5.16/test/%s/Go", runtime.GOOS)
+ if clientString != expected {
+ t.Error("Expected clientIdentity to be %v, got %v", expected, clientString)
+ }
+ customIdentifier := clientIdentity.GetCustomIdentifier()
+ if customIdentifier != "test" {
+ t.Error("Expected clientIdentity.GetCustomIdentifier() to be 'test', got %v", customIdentifier)
+ }
+ clientIdentity.SetCustomIdentifier("test2")
+ customIdentifier = clientIdentity.GetCustomIdentifier()
+ if customIdentifier != "test2" {
+ t.Error("Expected clientIdentity.GetCustomIdentifier() to be 'test2', got %v", customIdentifier)
+ }
+ clientString = clientIdentity.String()
+ expected = fmt.Sprintf("Ethereum(G)/v0.5.16/test2/%s/Go", runtime.GOOS)
+ if clientString != expected {
+ t.Error("Expected clientIdentity to be %v, got %v", expected, clientString)
+ }
+}
diff --git a/ethwire/messages2.go b/ethwire/messages2.go
new file mode 100644
index 0000000000000000000000000000000000000000..ebbc7c912103777f84597573fed02090cc884d72
--- /dev/null
+++ b/ethwire/messages2.go
@@ -0,0 +1,199 @@
+package ethwire
+
+import (
+ "bytes"
+ "errors"
+ "fmt"
+ "net"
+ "time"
+
+ "github.com/ethereum/go-ethereum/ethutil"
+)
+
+// The connection object allows you to set up a connection to the Ethereum network.
+// The Connection object takes care of all encoding and sending objects properly over
+// the network.
+type Connection struct {
+ conn net.Conn
+ nTimeout time.Duration
+ pendingMessages Messages
+}
+
+// Create a new connection to the Ethereum network
+func New(conn net.Conn) *Connection {
+ return &Connection{conn: conn, nTimeout: 500}
+}
+
+// Read, reads from the network. It will block until the next message is received.
+func (self *Connection) Read() *Msg {
+ if len(self.pendingMessages) == 0 {
+ self.readMessages()
+ }
+
+ ret := self.pendingMessages[0]
+ self.pendingMessages = self.pendingMessages[1:]
+
+ return ret
+
+}
+
+// Write to the Ethereum network specifying the type of the message and
+// the data. Data can be of type RlpEncodable or []interface{}. Returns
+// nil or if something went wrong an error.
+func (self *Connection) Write(typ MsgType, v ...interface{}) error {
+ var pack []byte
+
+ slice := [][]interface{}{[]interface{}{byte(typ)}}
+ for _, value := range v {
+ if encodable, ok := value.(ethutil.RlpEncodeDecode); ok {
+ slice = append(slice, encodable.RlpValue())
+ } else if raw, ok := value.([]interface{}); ok {
+ slice = append(slice, raw)
+ } else {
+ panic(fmt.Sprintf("Unable to 'write' object of type %T", value))
+ }
+ }
+
+ // Encode the type and the (RLP encoded) data for sending over the wire
+ encoded := ethutil.NewValue(slice).Encode()
+ payloadLength := ethutil.NumberToBytes(uint32(len(encoded)), 32)
+
+ // Write magic token and payload length (first 8 bytes)
+ pack = append(MagicToken, payloadLength...)
+ pack = append(pack, encoded...)
+
+ // Write to the connection
+ _, err := self.conn.Write(pack)
+ if err != nil {
+ return err
+ }
+
+ return nil
+}
+
+func (self *Connection) readMessage(data []byte) (msg *Msg, remaining []byte, done bool, err error) {
+ if len(data) == 0 {
+ return nil, nil, true, nil
+ }
+
+ if len(data) <= 8 {
+ return nil, remaining, false, errors.New("Invalid message")
+ }
+
+ // Check if the received 4 first bytes are the magic token
+ if bytes.Compare(MagicToken, data[:4]) != 0 {
+ return nil, nil, false, fmt.Errorf("MagicToken mismatch. Received %v", data[:4])
+ }
+
+ messageLength := ethutil.BytesToNumber(data[4:8])
+ remaining = data[8+messageLength:]
+ if int(messageLength) > len(data[8:]) {
+ return nil, nil, false, fmt.Errorf("message length %d, expected %d", len(data[8:]), messageLength)
+ }
+
+ message := data[8 : 8+messageLength]
+ decoder := ethutil.NewValueFromBytes(message)
+ // Type of message
+ t := decoder.Get(0).Uint()
+ // Actual data
+ d := decoder.SliceFrom(1)
+
+ msg = &Msg{
+ Type: MsgType(t),
+ Data: d,
+ }
+
+ return
+}
+
+// The basic message reader waits for data on the given connection, decoding
+// and doing a few sanity checks such as if there's a data type and
+// unmarhals the given data
+func (self *Connection) readMessages() (err error) {
+ // The recovering function in case anything goes horribly wrong
+ defer func() {
+ if r := recover(); r != nil {
+ err = fmt.Errorf("ethwire.ReadMessage error: %v", r)
+ }
+ }()
+
+ // Buff for writing network message to
+ //buff := make([]byte, 1440)
+ var buff []byte
+ var totalBytes int
+ for {
+ // Give buffering some time
+ self.conn.SetReadDeadline(time.Now().Add(self.nTimeout * time.Millisecond))
+ // Create a new temporarily buffer
+ b := make([]byte, 1440)
+ // Wait for a message from this peer
+ n, _ := self.conn.Read(b)
+ if err != nil && n == 0 {
+ if err.Error() != "EOF" {
+ fmt.Println("err now", err)
+ return err
+ } else {
+ break
+ }
+
+ // Messages can't be empty
+ } else if n == 0 {
+ break
+ }
+
+ buff = append(buff, b[:n]...)
+ totalBytes += n
+ }
+
+ // Reslice buffer
+ buff = buff[:totalBytes]
+ msg, remaining, done, err := self.readMessage(buff)
+ for ; done != true; msg, remaining, done, err = self.readMessage(remaining) {
+ //log.Println("rx", msg)
+
+ if msg != nil {
+ self.pendingMessages = append(self.pendingMessages, msg)
+ }
+ }
+
+ return
+}
+
+func ReadMessage(data []byte) (msg *Msg, remaining []byte, done bool, err error) {
+ if len(data) == 0 {
+ return nil, nil, true, nil
+ }
+
+ if len(data) <= 8 {
+ return nil, remaining, false, errors.New("Invalid message")
+ }
+
+ // Check if the received 4 first bytes are the magic token
+ if bytes.Compare(MagicToken, data[:4]) != 0 {
+ return nil, nil, false, fmt.Errorf("MagicToken mismatch. Received %v", data[:4])
+ }
+
+ messageLength := ethutil.BytesToNumber(data[4:8])
+ remaining = data[8+messageLength:]
+ if int(messageLength) > len(data[8:]) {
+ return nil, nil, false, fmt.Errorf("message length %d, expected %d", len(data[8:]), messageLength)
+ }
+
+ message := data[8 : 8+messageLength]
+ decoder := ethutil.NewValueFromBytes(message)
+ // Type of message
+ t := decoder.Get(0).Uint()
+ // Actual data
+ d := decoder.SliceFrom(1)
+
+ msg = &Msg{
+ Type: MsgType(t),
+ Data: d,
+ }
+
+ return
+}
+
+func bufferedRead(conn net.Conn) ([]byte, error) {
+ return nil, nil
+}
diff --git a/ethwire/messaging.go b/ethwire/messaging.go
new file mode 100644
index 0000000000000000000000000000000000000000..f1757f40fdc72dd52e21647ca8e1ea80f6ff9d1e
--- /dev/null
+++ b/ethwire/messaging.go
@@ -0,0 +1,179 @@
+// Package ethwire provides low level access to the Ethereum network and allows
+// you to broadcast data over the network.
+package ethwire
+
+import (
+ "bytes"
+ "fmt"
+ "net"
+ "time"
+
+ "github.com/ethereum/go-ethereum/ethutil"
+)
+
+// Connection interface describing the methods required to implement the wire protocol.
+type Conn interface {
+ Write(typ MsgType, v ...interface{}) error
+ Read() *Msg
+}
+
+// The magic token which should be the first 4 bytes of every message and can be used as separator between messages.
+var MagicToken = []byte{34, 64, 8, 145}
+
+type MsgType byte
+
+const (
+ // Values are given explicitly instead of by iota because these values are
+ // defined by the wire protocol spec; it is easier for humans to ensure
+ // correctness when values are explicit.
+ MsgHandshakeTy = 0x00
+ MsgDiscTy = 0x01
+ MsgPingTy = 0x02
+ MsgPongTy = 0x03
+ MsgGetPeersTy = 0x04
+ MsgPeersTy = 0x05
+
+ MsgStatusTy = 0x10
+ //MsgGetTxsTy = 0x11
+ MsgTxTy = 0x12
+ MsgGetBlockHashesTy = 0x13
+ MsgBlockHashesTy = 0x14
+ MsgGetBlocksTy = 0x15
+ MsgBlockTy = 0x16
+ MsgNewBlockTy = 0x17
+)
+
+var msgTypeToString = map[MsgType]string{
+ MsgHandshakeTy: "Handshake",
+ MsgDiscTy: "Disconnect",
+ MsgPingTy: "Ping",
+ MsgPongTy: "Pong",
+ MsgGetPeersTy: "Get peers",
+ MsgStatusTy: "Status",
+ MsgPeersTy: "Peers",
+ MsgTxTy: "Transactions",
+ MsgBlockTy: "Blocks",
+ //MsgGetTxsTy: "Get Txs",
+ MsgGetBlockHashesTy: "Get block hashes",
+ MsgBlockHashesTy: "Block hashes",
+ MsgGetBlocksTy: "Get blocks",
+}
+
+func (mt MsgType) String() string {
+ return msgTypeToString[mt]
+}
+
+type Msg struct {
+ Type MsgType // Specifies how the encoded data should be interpreted
+ //Data []byte
+ Data *ethutil.Value
+}
+
+func NewMessage(msgType MsgType, data interface{}) *Msg {
+ return &Msg{
+ Type: msgType,
+ Data: ethutil.NewValue(data),
+ }
+}
+
+type Messages []*Msg
+
+// The basic message reader waits for data on the given connection, decoding
+// and doing a few sanity checks such as if there's a data type and
+// unmarhals the given data
+func ReadMessages(conn net.Conn) (msgs []*Msg, err error) {
+ // The recovering function in case anything goes horribly wrong
+ defer func() {
+ if r := recover(); r != nil {
+ err = fmt.Errorf("ethwire.ReadMessage error: %v", r)
+ }
+ }()
+
+ var (
+ buff []byte
+ messages [][]byte
+ msgLength int
+ )
+
+ for {
+ // Give buffering some time
+ conn.SetReadDeadline(time.Now().Add(5 * time.Millisecond))
+ // Create a new temporarily buffer
+ b := make([]byte, 1440)
+ n, _ := conn.Read(b)
+ if err != nil && n == 0 {
+ if err.Error() != "EOF" {
+ fmt.Println("err now", err)
+ return nil, err
+ } else {
+ break
+ }
+ }
+
+ if n == 0 && len(buff) == 0 {
+ // If there's nothing on the wire wait for a bit
+ time.Sleep(200 * time.Millisecond)
+
+ continue
+ }
+
+ buff = append(buff, b[:n]...)
+ if msgLength == 0 {
+ // Check if the received 4 first bytes are the magic token
+ if bytes.Compare(MagicToken, buff[:4]) != 0 {
+ return nil, fmt.Errorf("MagicToken mismatch. Received %v", buff[:4])
+ }
+
+ // Read the length of the message
+ msgLength = int(ethutil.BytesToNumber(buff[4:8]))
+
+ // Remove the token and length
+ buff = buff[8:]
+ }
+
+ if len(buff) >= msgLength {
+ messages = append(messages, buff[:msgLength])
+ buff = buff[msgLength:]
+ msgLength = 0
+
+ if len(buff) == 0 {
+ break
+ }
+ }
+ }
+
+ for _, m := range messages {
+ decoder := ethutil.NewValueFromBytes(m)
+ // Type of message
+ t := decoder.Get(0).Uint()
+ // Actual data
+ d := decoder.SliceFrom(1)
+
+ msgs = append(msgs, &Msg{Type: MsgType(t), Data: d})
+ }
+
+ return
+}
+
+// The basic message writer takes care of writing data over the given
+// connection and does some basic error checking
+func WriteMessage(conn net.Conn, msg *Msg) error {
+ var pack []byte
+
+ // Encode the type and the (RLP encoded) data for sending over the wire
+ encoded := ethutil.NewValue(append([]interface{}{byte(msg.Type)}, msg.Data.Slice()...)).Encode()
+ payloadLength := ethutil.NumberToBytes(uint32(len(encoded)), 32)
+
+ // Write magic token and payload length (first 8 bytes)
+ pack = append(MagicToken, payloadLength...)
+ pack = append(pack, encoded...)
+ //fmt.Printf("payload %v (%v) %q\n", msg.Type, conn.RemoteAddr(), encoded)
+
+ // Write to the connection
+ _, err := conn.Write(pack)
+ if err != nil {
+ return err
+ }
+
+ return nil
+}
diff --git a/event/event.go b/event/event.go
new file mode 100644
index 0000000000000000000000000000000000000000..540fbba65a49639641cc6cfbc7ea67bab1be29ae
--- /dev/null
+++ b/event/event.go
@@ -0,0 +1,183 @@
+// Package event implements an event multiplexer.
+package event
+
+import (
+ "errors"
+ "fmt"
+ "reflect"
+ "sync"
+)
+
+// Subscription is implemented by event subscriptions.
+type Subscription interface {
+ // Chan returns a channel that carries events.
+ // Implementations should return the same channel
+ // for any subsequent calls to Chan.
+ Chan() <-chan interface{}
+
+ // Unsubscribe stops delivery of events to a subscription.
+ // The event channel is closed.
+ // Unsubscribe can be called more than once.
+ Unsubscribe()
+}
+
+// A TypeMux dispatches events to registered receivers. Receivers can be
+// registered to handle events of certain type. Any operation
+// called after mux is stopped will return ErrMuxClosed.
+//
+// The zero value is ready to use.
+type TypeMux struct {
+ mutex sync.RWMutex
+ subm map[reflect.Type][]*muxsub
+ stopped bool
+}
+
+// ErrMuxClosed is returned when Posting on a closed TypeMux.
+var ErrMuxClosed = errors.New("event: mux closed")
+
+// Subscribe creates a subscription for events of the given types. The
+// subscription's channel is closed when it is unsubscribed
+// or the mux is closed.
+func (mux *TypeMux) Subscribe(types ...interface{}) Subscription {
+ sub := newsub(mux)
+ mux.mutex.Lock()
+ defer mux.mutex.Unlock()
+ if mux.stopped {
+ close(sub.postC)
+ } else {
+ if mux.subm == nil {
+ mux.subm = make(map[reflect.Type][]*muxsub)
+ }
+ for _, t := range types {
+ rtyp := reflect.TypeOf(t)
+ oldsubs := mux.subm[rtyp]
+ if find(oldsubs, sub) != -1 {
+ panic(fmt.Sprintf("event: duplicate type %s in Subscribe", rtyp))
+ }
+ subs := make([]*muxsub, len(oldsubs)+1)
+ copy(subs, oldsubs)
+ subs[len(oldsubs)] = sub
+ mux.subm[rtyp] = subs
+ }
+ }
+ return sub
+}
+
+// Post sends an event to all receivers registered for the given type.
+// It returns ErrMuxClosed if the mux has been stopped.
+func (mux *TypeMux) Post(ev interface{}) error {
+ rtyp := reflect.TypeOf(ev)
+ mux.mutex.RLock()
+ if mux.stopped {
+ mux.mutex.RUnlock()
+ return ErrMuxClosed
+ }
+ subs := mux.subm[rtyp]
+ mux.mutex.RUnlock()
+ for _, sub := range subs {
+ sub.deliver(ev)
+ }
+ return nil
+}
+
+// Stop closes a mux. The mux can no longer be used.
+// Future Post calls will fail with ErrMuxClosed.
+// Stop blocks until all current deliveries have finished.
+func (mux *TypeMux) Stop() {
+ mux.mutex.Lock()
+ for _, subs := range mux.subm {
+ for _, sub := range subs {
+ sub.closewait()
+ }
+ }
+ mux.subm = nil
+ mux.stopped = true
+ mux.mutex.Unlock()
+}
+
+func (mux *TypeMux) del(s *muxsub) {
+ mux.mutex.Lock()
+ for typ, subs := range mux.subm {
+ if pos := find(subs, s); pos >= 0 {
+ if len(subs) == 1 {
+ delete(mux.subm, typ)
+ } else {
+ mux.subm[typ] = posdelete(subs, pos)
+ }
+ }
+ }
+ s.mux.mutex.Unlock()
+}
+
+func find(slice []*muxsub, item *muxsub) int {
+ for i, v := range slice {
+ if v == item {
+ return i
+ }
+ }
+ return -1
+}
+
+func posdelete(slice []*muxsub, pos int) []*muxsub {
+ news := make([]*muxsub, len(slice)-1)
+ copy(news[:pos], slice[:pos])
+ copy(news[pos:], slice[pos+1:])
+ return news
+}
+
+type muxsub struct {
+ mux *TypeMux
+ closeMu sync.Mutex
+ closing chan struct{}
+ closed bool
+
+ // these two are the same channel. they are stored separately so
+ // postC can be set to nil without affecting the return value of
+ // Chan.
+ postMu sync.RWMutex
+ readC <-chan interface{}
+ postC chan<- interface{}
+}
+
+func newsub(mux *TypeMux) *muxsub {
+ c := make(chan interface{})
+ return &muxsub{
+ mux: mux,
+ readC: c,
+ postC: c,
+ closing: make(chan struct{}),
+ }
+}
+
+func (s *muxsub) Chan() <-chan interface{} {
+ return s.readC
+}
+
+func (s *muxsub) Unsubscribe() {
+ s.mux.del(s)
+ s.closewait()
+}
+
+func (s *muxsub) closewait() {
+ s.closeMu.Lock()
+ defer s.closeMu.Unlock()
+ if s.closed {
+ return
+ }
+ close(s.closing)
+ s.closed = true
+
+ s.postMu.Lock()
+ close(s.postC)
+ s.postC = nil
+ s.postMu.Unlock()
+}
+
+func (s *muxsub) deliver(ev interface{}) {
+ s.postMu.RLock()
+ select {
+ case s.postC <- ev:
+ case <-s.closing:
+ }
+ s.postMu.RUnlock()
+}
diff --git a/event/event_test.go b/event/event_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..c7c0266c1a798033405a2001804907594e57373a
--- /dev/null
+++ b/event/event_test.go
@@ -0,0 +1,176 @@
+package event
+
+import (
+ "math/rand"
+ "sync"
+ "testing"
+ "time"
+)
+
+type testEvent int
+
+func TestSub(t *testing.T) {
+ mux := new(TypeMux)
+ defer mux.Stop()
+
+ sub := mux.Subscribe(testEvent(0))
+ go func() {
+ if err := mux.Post(testEvent(5)); err != nil {
+ t.Errorf("Post returned unexpected error: %v", err)
+ }
+ }()
+ ev := <-sub.Chan()
+
+ if ev.(testEvent) != testEvent(5) {
+ t.Errorf("Got %v (%T), expected event %v (%T)",
+ ev, ev, testEvent(5), testEvent(5))
+ }
+}
+
+func TestMuxErrorAfterStop(t *testing.T) {
+ mux := new(TypeMux)
+ mux.Stop()
+
+ sub := mux.Subscribe(testEvent(0))
+ if _, isopen := <-sub.Chan(); isopen {
+ t.Errorf("subscription channel was not closed")
+ }
+ if err := mux.Post(testEvent(0)); err != ErrMuxClosed {
+ t.Errorf("Post error mismatch, got: %s, expected: %s", err, ErrMuxClosed)
+ }
+}
+
+func TestUnsubscribeUnblockPost(t *testing.T) {
+ mux := new(TypeMux)
+ defer mux.Stop()
+
+ sub := mux.Subscribe(testEvent(0))
+ unblocked := make(chan bool)
+ go func() {
+ mux.Post(testEvent(5))
+ unblocked <- true
+ }()
+
+ select {
+ case <-unblocked:
+ t.Errorf("Post returned before Unsubscribe")
+ default:
+ sub.Unsubscribe()
+ <-unblocked
+ }
+}
+
+func TestSubscribeDuplicateType(t *testing.T) {
+ mux := new(TypeMux)
+ expected := "event: duplicate type event.testEvent in Subscribe"
+
+ defer func() {
+ err := recover()
+ if err == nil {
+ t.Errorf("Subscribe didn't panic for duplicate type")
+ } else if err != expected {
+ t.Errorf("panic mismatch: got %#v, expected %#v", err, expected)
+ }
+ }()
+ mux.Subscribe(testEvent(1), testEvent(2))
+}
+
+func TestMuxConcurrent(t *testing.T) {
+ rand.Seed(time.Now().Unix())
+ mux := new(TypeMux)
+ defer mux.Stop()
+
+ recv := make(chan int)
+ poster := func() {
+ for {
+ err := mux.Post(testEvent(0))
+ if err != nil {
+ return
+ }
+ }
+ }
+ sub := func(i int) {
+ time.Sleep(time.Duration(rand.Intn(99)) * time.Millisecond)
+ sub := mux.Subscribe(testEvent(0))
+ <-sub.Chan()
+ sub.Unsubscribe()
+ recv <- i
+ }
+
+ go poster()
+ go poster()
+ go poster()
+ nsubs := 1000
+ for i := 0; i < nsubs; i++ {
+ go sub(i)
+ }
+
+ // wait until everyone has been served
+ counts := make(map[int]int, nsubs)
+ for i := 0; i < nsubs; i++ {
+ counts[<-recv]++
+ }
+ for i, count := range counts {
+ if count != 1 {
+ t.Errorf("receiver %d called %d times, expected only 1 call", i, count)
+ }
+ }
+}
+
+func emptySubscriber(mux *TypeMux, types ...interface{}) {
+ s := mux.Subscribe(testEvent(0))
+ go func() {
+ for _ = range s.Chan() {
+ }
+ }()
+}
+
+func BenchmarkPost3(b *testing.B) {
+ var mux = new(TypeMux)
+ defer mux.Stop()
+ emptySubscriber(mux, testEvent(0))
+ emptySubscriber(mux, testEvent(0))
+ emptySubscriber(mux, testEvent(0))
+
+ for i := 0; i < b.N; i++ {
+ mux.Post(testEvent(0))
+ }
+}
+
+func BenchmarkPostConcurrent(b *testing.B) {
+ var mux = new(TypeMux)
+ defer mux.Stop()
+ emptySubscriber(mux, testEvent(0))
+ emptySubscriber(mux, testEvent(0))
+ emptySubscriber(mux, testEvent(0))
+
+ var wg sync.WaitGroup
+ poster := func() {
+ for i := 0; i < b.N; i++ {
+ mux.Post(testEvent(0))
+ }
+ wg.Done()
+ }
+ wg.Add(5)
+ for i := 0; i < 5; i++ {
+ go poster()
+ }
+ wg.Wait()
+}
+
+// for comparison
+func BenchmarkChanSend(b *testing.B) {
+ c := make(chan interface{})
+ closed := make(chan struct{})
+ go func() {
+ for _ = range c {
+ }
+ }()
+
+ for i := 0; i < b.N; i++ {
+ select {
+ case c <- i:
+ case <-closed:
+ }
+ }
+}
diff --git a/event/example_test.go b/event/example_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..2f47f6f27e4778c2d9f1ace06fcc1615429a9068
--- /dev/null
+++ b/event/example_test.go
@@ -0,0 +1,42 @@
+package event
+
+import "fmt"
+
+func ExampleTypeMux() {
+ type someEvent struct{ I int }
+ type otherEvent struct{ S string }
+ type yetAnotherEvent struct{ X, Y int }
+
+ var mux TypeMux
+
+ // Start a subscriber.
+ done := make(chan struct{})
+ sub := mux.Subscribe(someEvent{}, otherEvent{})
+ go func() {
+ for event := range sub.Chan() {
+ fmt.Printf("Received: %#v\n", event)
+ }
+ fmt.Println("done")
+ close(done)
+ }()
+
+ // Post some events.
+ mux.Post(someEvent{5})
+ mux.Post(yetAnotherEvent{X: 3, Y: 4})
+ mux.Post(someEvent{6})
+ mux.Post(otherEvent{"whoa"})
+
+ // Stop closes all subscription channels.
+ // The subscriber goroutine will print "done"
+ // and exit.
+ mux.Stop()
+
+ // Wait for subscriber to return.
+ <-done
+
+ // Output:
+ // Received: event.someEvent{I:5}
+ // Received: event.someEvent{I:6}
+ // Received: event.otherEvent{S:"whoa"}
+ // done
+}
diff --git a/events.go b/events.go
new file mode 100644
index 0000000000000000000000000000000000000000..5fff1d8314e6322b3ebedb0af18a4a1b971e8003
--- /dev/null
+++ b/events.go
@@ -0,0 +1,11 @@
+package eth
+
+import "container/list"
+
+type PeerListEvent struct {
+ Peers *list.List
+}
+
+type ChainSyncEvent struct {
+ InSync bool
+}
diff --git a/install.sh b/install.sh
index f880aa39baf6f1ec9d328da103bdcebaef5bb9e9..40a6e4fd35428371da68295d596b2b31bcff320e 100755
--- a/install.sh
+++ b/install.sh
@@ -34,7 +34,7 @@ git submodule init
git submodule update
echo "eth-go"
-cd $GOPATH/src/github.com/ethereum/eth-go
+cd $GOPATH/src/github.com/ethereum/go-ethereum
git checkout $branch
echo "go-ethereum"
diff --git a/javascript/javascript_runtime.go b/javascript/javascript_runtime.go
index 189106ae90b3d0333754c34eb1bacef2f15f59ef..b0d7c81b52e5dfa2b99500aed2759f05f2040c15 100644
--- a/javascript/javascript_runtime.go
+++ b/javascript/javascript_runtime.go
@@ -7,13 +7,13 @@ import (
"path"
"path/filepath"
- "github.com/ethereum/eth-go"
- "github.com/ethereum/eth-go/ethchain"
- "github.com/ethereum/eth-go/ethlog"
- "github.com/ethereum/eth-go/ethpipe"
- "github.com/ethereum/eth-go/ethstate"
- "github.com/ethereum/eth-go/ethutil"
- "github.com/ethereum/eth-go/event"
+ "github.com/ethereum/go-ethereum"
+ "github.com/ethereum/go-ethereum/ethchain"
+ "github.com/ethereum/go-ethereum/ethlog"
+ "github.com/ethereum/go-ethereum/ethpipe"
+ "github.com/ethereum/go-ethereum/ethstate"
+ "github.com/ethereum/go-ethereum/ethutil"
+ "github.com/ethereum/go-ethereum/event"
"github.com/ethereum/go-ethereum/utils"
"github.com/obscuren/otto"
)
diff --git a/javascript/types.go b/javascript/types.go
index 560960f548b44ffd1db08e63cdc9ac19d371692d..b02ee9dc28aaad4ae58674bc01dff888374bd921 100644
--- a/javascript/types.go
+++ b/javascript/types.go
@@ -3,11 +3,11 @@ package javascript
import (
"fmt"
- "github.com/ethereum/eth-go"
- "github.com/ethereum/eth-go/ethpipe"
- "github.com/ethereum/eth-go/ethstate"
- "github.com/ethereum/eth-go/ethutil"
- "github.com/ethereum/eth-go/ui"
+ "github.com/ethereum/go-ethereum"
+ "github.com/ethereum/go-ethereum/ethpipe"
+ "github.com/ethereum/go-ethereum/ethstate"
+ "github.com/ethereum/go-ethereum/ethutil"
+ "github.com/ethereum/go-ethereum/ui"
"github.com/obscuren/otto"
)
diff --git a/nat.go b/nat.go
new file mode 100644
index 0000000000000000000000000000000000000000..999308eb267696493004f7b31614a1ad56be603b
--- /dev/null
+++ b/nat.go
@@ -0,0 +1,12 @@
+package eth
+
+import (
+ "net"
+)
+
+// protocol is either "udp" or "tcp"
+type NAT interface {
+ GetExternalAddress() (addr net.IP, err error)
+ AddPortMapping(protocol string, externalPort, internalPort int, description string, timeout int) (mappedExternalPort int, err error)
+ DeletePortMapping(protocol string, externalPort, internalPort int) (err error)
+}
diff --git a/natpmp.go b/natpmp.go
new file mode 100644
index 0000000000000000000000000000000000000000..489342a4be162876ff59f641218f6110e7ae4b99
--- /dev/null
+++ b/natpmp.go
@@ -0,0 +1,55 @@
+package eth
+
+import (
+ "fmt"
+ "net"
+
+ natpmp "github.com/jackpal/go-nat-pmp"
+)
+
+// Adapt the NAT-PMP protocol to the NAT interface
+
+// TODO:
+// + Register for changes to the external address.
+// + Re-register port mapping when router reboots.
+// + A mechanism for keeping a port mapping registered.
+
+type natPMPClient struct {
+ client *natpmp.Client
+}
+
+func NewNatPMP(gateway net.IP) (nat NAT) {
+ return &natPMPClient{natpmp.NewClient(gateway)}
+}
+
+func (n *natPMPClient) GetExternalAddress() (addr net.IP, err error) {
+ response, err := n.client.GetExternalAddress()
+ if err != nil {
+ return
+ }
+ ip := response.ExternalIPAddress
+ addr = net.IPv4(ip[0], ip[1], ip[2], ip[3])
+ return
+}
+
+func (n *natPMPClient) AddPortMapping(protocol string, externalPort, internalPort int,
+ description string, timeout int) (mappedExternalPort int, err error) {
+ if timeout <= 0 {
+ err = fmt.Errorf("timeout must not be <= 0")
+ return
+ }
+ // Note order of port arguments is switched between our AddPortMapping and the client's AddPortMapping.
+ response, err := n.client.AddPortMapping(protocol, internalPort, externalPort, timeout)
+ if err != nil {
+ return
+ }
+ mappedExternalPort = int(response.MappedExternalPort)
+ return
+}
+
+func (n *natPMPClient) DeletePortMapping(protocol string, externalPort, internalPort int) (err error) {
+ // To destroy a mapping, send an add-port with
+ // an internalPort of the internal port to destroy, an external port of zero and a time of zero.
+ _, err = n.client.AddPortMapping(protocol, internalPort, 0, 0)
+ return
+}
diff --git a/natupnp.go b/natupnp.go
new file mode 100644
index 0000000000000000000000000000000000000000..c7f9eeb622b30b3641cc51cbf3be29c63e73f21c
--- /dev/null
+++ b/natupnp.go
@@ -0,0 +1,338 @@
+package eth
+
+// Just enough UPnP to be able to forward ports
+//
+
+import (
+ "bytes"
+ "encoding/xml"
+ "errors"
+ "net"
+ "net/http"
+ "os"
+ "strconv"
+ "strings"
+ "time"
+)
+
+type upnpNAT struct {
+ serviceURL string
+ ourIP string
+}
+
+func Discover() (nat NAT, err error) {
+ ssdp, err := net.ResolveUDPAddr("udp4", "239.255.255.250:1900")
+ if err != nil {
+ return
+ }
+ conn, err := net.ListenPacket("udp4", ":0")
+ if err != nil {
+ return
+ }
+ socket := conn.(*net.UDPConn)
+ defer socket.Close()
+
+ err = socket.SetDeadline(time.Now().Add(10 * time.Second))
+ if err != nil {
+ return
+ }
+
+ st := "ST: urn:schemas-upnp-org:device:InternetGatewayDevice:1\r\n"
+ buf := bytes.NewBufferString(
+ "M-SEARCH * HTTP/1.1\r\n" +
+ "HOST: 239.255.255.250:1900\r\n" +
+ st +
+ "MAN: \"ssdp:discover\"\r\n" +
+ "MX: 2\r\n\r\n")
+ message := buf.Bytes()
+ answerBytes := make([]byte, 1024)
+ for i := 0; i < 3; i++ {
+ _, err = socket.WriteToUDP(message, ssdp)
+ if err != nil {
+ return
+ }
+ var n int
+ n, _, err = socket.ReadFromUDP(answerBytes)
+ if err != nil {
+ continue
+ // socket.Close()
+ // return
+ }
+ answer := string(answerBytes[0:n])
+ if strings.Index(answer, "\r\n"+st) < 0 {
+ continue
+ }
+ // HTTP header field names are case-insensitive.
+ // http://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html#sec4.2
+ locString := "\r\nlocation: "
+ answer = strings.ToLower(answer)
+ locIndex := strings.Index(answer, locString)
+ if locIndex < 0 {
+ continue
+ }
+ loc := answer[locIndex+len(locString):]
+ endIndex := strings.Index(loc, "\r\n")
+ if endIndex < 0 {
+ continue
+ }
+ locURL := loc[0:endIndex]
+ var serviceURL string
+ serviceURL, err = getServiceURL(locURL)
+ if err != nil {
+ return
+ }
+ var ourIP string
+ ourIP, err = getOurIP()
+ if err != nil {
+ return
+ }
+ nat = &upnpNAT{serviceURL: serviceURL, ourIP: ourIP}
+ return
+ }
+ err = errors.New("UPnP port discovery failed.")
+ return
+}
+
+// service represents the Service type in an UPnP xml description.
+// Only the parts we care about are present and thus the xml may have more
+// fields than present in the structure.
+type service struct {
+ ServiceType string `xml:"serviceType"`
+ ControlURL string `xml:"controlURL"`
+}
+
+// deviceList represents the deviceList type in an UPnP xml description.
+// Only the parts we care about are present and thus the xml may have more
+// fields than present in the structure.
+type deviceList struct {
+ XMLName xml.Name `xml:"deviceList"`
+ Device []device `xml:"device"`
+}
+
+// serviceList represents the serviceList type in an UPnP xml description.
+// Only the parts we care about are present and thus the xml may have more
+// fields than present in the structure.
+type serviceList struct {
+ XMLName xml.Name `xml:"serviceList"`
+ Service []service `xml:"service"`
+}
+
+// device represents the device type in an UPnP xml description.
+// Only the parts we care about are present and thus the xml may have more
+// fields than present in the structure.
+type device struct {
+ XMLName xml.Name `xml:"device"`
+ DeviceType string `xml:"deviceType"`
+ DeviceList deviceList `xml:"deviceList"`
+ ServiceList serviceList `xml:"serviceList"`
+}
+
+// specVersion represents the specVersion in a UPnP xml description.
+// Only the parts we care about are present and thus the xml may have more
+// fields than present in the structure.
+type specVersion struct {
+ XMLName xml.Name `xml:"specVersion"`
+ Major int `xml:"major"`
+ Minor int `xml:"minor"`
+}
+
+// root represents the Root document for a UPnP xml description.
+// Only the parts we care about are present and thus the xml may have more
+// fields than present in the structure.
+type root struct {
+ XMLName xml.Name `xml:"root"`
+ SpecVersion specVersion
+ Device device
+}
+
+func getChildDevice(d *device, deviceType string) *device {
+ dl := d.DeviceList.Device
+ for i := 0; i < len(dl); i++ {
+ if dl[i].DeviceType == deviceType {
+ return &dl[i]
+ }
+ }
+ return nil
+}
+
+func getChildService(d *device, serviceType string) *service {
+ sl := d.ServiceList.Service
+ for i := 0; i < len(sl); i++ {
+ if sl[i].ServiceType == serviceType {
+ return &sl[i]
+ }
+ }
+ return nil
+}
+
+func getOurIP() (ip string, err error) {
+ hostname, err := os.Hostname()
+ if err != nil {
+ return
+ }
+ p, err := net.LookupIP(hostname)
+ if err != nil && len(p) > 0 {
+ return
+ }
+ return p[0].String(), nil
+}
+
+func getServiceURL(rootURL string) (url string, err error) {
+ r, err := http.Get(rootURL)
+ if err != nil {
+ return
+ }
+ defer r.Body.Close()
+ if r.StatusCode >= 400 {
+ err = errors.New(string(r.StatusCode))
+ return
+ }
+ var root root
+ err = xml.NewDecoder(r.Body).Decode(&root)
+
+ if err != nil {
+ return
+ }
+ a := &root.Device
+ if a.DeviceType != "urn:schemas-upnp-org:device:InternetGatewayDevice:1" {
+ err = errors.New("No InternetGatewayDevice")
+ return
+ }
+ b := getChildDevice(a, "urn:schemas-upnp-org:device:WANDevice:1")
+ if b == nil {
+ err = errors.New("No WANDevice")
+ return
+ }
+ c := getChildDevice(b, "urn:schemas-upnp-org:device:WANConnectionDevice:1")
+ if c == nil {
+ err = errors.New("No WANConnectionDevice")
+ return
+ }
+ d := getChildService(c, "urn:schemas-upnp-org:service:WANIPConnection:1")
+ if d == nil {
+ err = errors.New("No WANIPConnection")
+ return
+ }
+ url = combineURL(rootURL, d.ControlURL)
+ return
+}
+
+func combineURL(rootURL, subURL string) string {
+ protocolEnd := "://"
+ protoEndIndex := strings.Index(rootURL, protocolEnd)
+ a := rootURL[protoEndIndex+len(protocolEnd):]
+ rootIndex := strings.Index(a, "/")
+ return rootURL[0:protoEndIndex+len(protocolEnd)+rootIndex] + subURL
+}
+
+func soapRequest(url, function, message string) (r *http.Response, err error) {
+ fullMessage := "<?xml version=\"1.0\" ?>" +
+ "<s:Envelope xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\" s:encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\">\r\n" +
+ "<s:Body>" + message + "</s:Body></s:Envelope>"
+
+ req, err := http.NewRequest("POST", url, strings.NewReader(fullMessage))
+ if err != nil {
+ return nil, err
+ }
+ req.Header.Set("Content-Type", "text/xml ; charset=\"utf-8\"")
+ req.Header.Set("User-Agent", "Darwin/10.0.0, UPnP/1.0, MiniUPnPc/1.3")
+ //req.Header.Set("Transfer-Encoding", "chunked")
+ req.Header.Set("SOAPAction", "\"urn:schemas-upnp-org:service:WANIPConnection:1#"+function+"\"")
+ req.Header.Set("Connection", "Close")
+ req.Header.Set("Cache-Control", "no-cache")
+ req.Header.Set("Pragma", "no-cache")
+
+ // log.Stderr("soapRequest ", req)
+ //fmt.Println(fullMessage)
+
+ r, err = http.DefaultClient.Do(req)
+ if err != nil {
+ return
+ }
+
+ if r.Body != nil {
+ defer r.Body.Close()
+ }
+
+ if r.StatusCode >= 400 {
+ // log.Stderr(function, r.StatusCode)
+ err = errors.New("Error " + strconv.Itoa(r.StatusCode) + " for " + function)
+ r = nil
+ return
+ }
+ return
+}
+
+type statusInfo struct {
+ externalIpAddress string
+}
+
+func (n *upnpNAT) getStatusInfo() (info statusInfo, err error) {
+
+ message := "<u:GetStatusInfo xmlns:u=\"urn:schemas-upnp-org:service:WANIPConnection:1\">\r\n" +
+ "</u:GetStatusInfo>"
+
+ var response *http.Response
+ response, err = soapRequest(n.serviceURL, "GetStatusInfo", message)
+ if err != nil {
+ return
+ }
+
+ // TODO: Write a soap reply parser. It has to eat the Body and envelope tags...
+
+ response.Body.Close()
+ return
+}
+
+func (n *upnpNAT) GetExternalAddress() (addr net.IP, err error) {
+ info, err := n.getStatusInfo()
+ if err != nil {
+ return
+ }
+ addr = net.ParseIP(info.externalIpAddress)
+ return
+}
+
+func (n *upnpNAT) AddPortMapping(protocol string, externalPort, internalPort int, description string, timeout int) (mappedExternalPort int, err error) {
+ // A single concatenation would break ARM compilation.
+ message := "<u:AddPortMapping xmlns:u=\"urn:schemas-upnp-org:service:WANIPConnection:1\">\r\n" +
+ "<NewRemoteHost></NewRemoteHost><NewExternalPort>" + strconv.Itoa(externalPort)
+ message += "</NewExternalPort><NewProtocol>" + protocol + "</NewProtocol>"
+ message += "<NewInternalPort>" + strconv.Itoa(internalPort) + "</NewInternalPort>" +
+ "<NewInternalClient>" + n.ourIP + "</NewInternalClient>" +
+ "<NewEnabled>1</NewEnabled><NewPortMappingDescription>"
+ message += description +
+ "</NewPortMappingDescription><NewLeaseDuration>" + strconv.Itoa(timeout) +
+ "</NewLeaseDuration></u:AddPortMapping>"
+
+ var response *http.Response
+ response, err = soapRequest(n.serviceURL, "AddPortMapping", message)
+ if err != nil {
+ return
+ }
+
+ // TODO: check response to see if the port was forwarded
+ // log.Println(message, response)
+ mappedExternalPort = externalPort
+ _ = response
+ return
+}
+
+func (n *upnpNAT) DeletePortMapping(protocol string, externalPort, internalPort int) (err error) {
+
+ message := "<u:DeletePortMapping xmlns:u=\"urn:schemas-upnp-org:service:WANIPConnection:1\">\r\n" +
+ "<NewRemoteHost></NewRemoteHost><NewExternalPort>" + strconv.Itoa(externalPort) +
+ "</NewExternalPort><NewProtocol>" + protocol + "</NewProtocol>" +
+ "</u:DeletePortMapping>"
+
+ var response *http.Response
+ response, err = soapRequest(n.serviceURL, "DeletePortMapping", message)
+ if err != nil {
+ return
+ }
+
+ // TODO: check response to see if the port was deleted
+ // log.Println(message, response)
+ _ = response
+ return
+}
diff --git a/peer.go b/peer.go
new file mode 100644
index 0000000000000000000000000000000000000000..291ba08e60aa1f690035af13de9ab9804d8224c3
--- /dev/null
+++ b/peer.go
@@ -0,0 +1,892 @@
+package eth
+
+import (
+ "bytes"
+ "container/list"
+ "fmt"
+ "math"
+ "math/big"
+ "net"
+ "strconv"
+ "strings"
+ "sync/atomic"
+ "time"
+
+ "github.com/ethereum/go-ethereum/ethchain"
+ "github.com/ethereum/go-ethereum/ethlog"
+ "github.com/ethereum/go-ethereum/ethutil"
+ "github.com/ethereum/go-ethereum/ethwire"
+)
+
+var peerlogger = ethlog.NewLogger("PEER")
+
+const (
+ // The size of the output buffer for writing messages
+ outputBufferSize = 50
+ // Current protocol version
+ ProtocolVersion = 36
+ // Current P2P version
+ P2PVersion = 2
+ // Ethereum network version
+ NetVersion = 0
+ // Interval for ping/pong message
+ pingPongTimer = 2 * time.Second
+)
+
+type DiscReason byte
+
+const (
+ // Values are given explicitly instead of by iota because these values are
+ // defined by the wire protocol spec; it is easier for humans to ensure
+ // correctness when values are explicit.
+ DiscRequested DiscReason = iota
+ DiscReTcpSysErr
+ DiscBadProto
+ DiscBadPeer
+ DiscTooManyPeers
+ DiscConnDup
+ DiscGenesisErr
+ DiscProtoErr
+ DiscQuitting
+)
+
+var discReasonToString = []string{
+ "requested",
+ "TCP sys error",
+ "bad protocol",
+ "useless peer",
+ "too many peers",
+ "already connected",
+ "wrong genesis block",
+ "incompatible network",
+ "quitting",
+}
+
+func (d DiscReason) String() string {
+ if len(discReasonToString) < int(d) {
+ return "Unknown"
+ }
+
+ return discReasonToString[d]
+}
+
+// Peer capabilities
+type Caps byte
+
+const (
+ CapPeerDiscTy Caps = 1 << iota
+ CapTxTy
+ CapChainTy
+
+ CapDefault = CapChainTy | CapTxTy | CapPeerDiscTy
+)
+
+var capsToString = map[Caps]string{
+ CapPeerDiscTy: "Peer discovery",
+ CapTxTy: "Transaction relaying",
+ CapChainTy: "Block chain relaying",
+}
+
+func (c Caps) IsCap(cap Caps) bool {
+ return c&cap > 0
+}
+
+func (c Caps) String() string {
+ var caps []string
+ if c.IsCap(CapPeerDiscTy) {
+ caps = append(caps, capsToString[CapPeerDiscTy])
+ }
+ if c.IsCap(CapChainTy) {
+ caps = append(caps, capsToString[CapChainTy])
+ }
+ if c.IsCap(CapTxTy) {
+ caps = append(caps, capsToString[CapTxTy])
+ }
+
+ return strings.Join(caps, " | ")
+}
+
+type Peer struct {
+ // Ethereum interface
+ ethereum *Ethereum
+ // Net connection
+ conn net.Conn
+ // Output queue which is used to communicate and handle messages
+ outputQueue chan *ethwire.Msg
+ // Quit channel
+ quit chan bool
+ // Determines whether it's an inbound or outbound peer
+ inbound bool
+ // Flag for checking the peer's connectivity state
+ connected int32
+ disconnect int32
+ // Last known message send
+ lastSend time.Time
+ // Indicated whether a verack has been send or not
+ // This flag is used by writeMessage to check if messages are allowed
+ // to be send or not. If no version is known all messages are ignored.
+ versionKnown bool
+ statusKnown bool
+
+ // Last received pong message
+ lastPong int64
+ lastBlockReceived time.Time
+ doneFetchingHashes bool
+
+ host []byte
+ port uint16
+ caps Caps
+ td *big.Int
+ bestHash []byte
+ lastReceivedHash []byte
+ requestedHashes [][]byte
+
+ // This peer's public key
+ pubkey []byte
+
+ // Indicated whether the node is catching up or not
+ catchingUp bool
+ diverted bool
+ blocksRequested int
+
+ version string
+
+ // We use this to give some kind of pingtime to a node, not very accurate, could be improved.
+ pingTime time.Duration
+ pingStartTime time.Time
+
+ lastRequestedBlock *ethchain.Block
+
+ protocolCaps *ethutil.Value
+}
+
+func NewPeer(conn net.Conn, ethereum *Ethereum, inbound bool) *Peer {
+ pubkey := ethereum.KeyManager().PublicKey()[1:]
+
+ return &Peer{
+ outputQueue: make(chan *ethwire.Msg, outputBufferSize),
+ quit: make(chan bool),
+ ethereum: ethereum,
+ conn: conn,
+ inbound: inbound,
+ disconnect: 0,
+ connected: 1,
+ port: 30303,
+ pubkey: pubkey,
+ blocksRequested: 10,
+ caps: ethereum.ServerCaps(),
+ version: ethereum.ClientIdentity().String(),
+ protocolCaps: ethutil.NewValue(nil),
+ td: big.NewInt(0),
+ doneFetchingHashes: true,
+ }
+}
+
+func NewOutboundPeer(addr string, ethereum *Ethereum, caps Caps) *Peer {
+ p := &Peer{
+ outputQueue: make(chan *ethwire.Msg, outputBufferSize),
+ quit: make(chan bool),
+ ethereum: ethereum,
+ inbound: false,
+ connected: 0,
+ disconnect: 0,
+ port: 30303,
+ caps: caps,
+ version: ethereum.ClientIdentity().String(),
+ protocolCaps: ethutil.NewValue(nil),
+ td: big.NewInt(0),
+ doneFetchingHashes: true,
+ }
+
+ // Set up the connection in another goroutine so we don't block the main thread
+ go func() {
+ conn, err := p.Connect(addr)
+ if err != nil {
+ //peerlogger.Debugln("Connection to peer failed. Giving up.", err)
+ p.Stop()
+ return
+ }
+ p.conn = conn
+
+ // Atomically set the connection state
+ atomic.StoreInt32(&p.connected, 1)
+ atomic.StoreInt32(&p.disconnect, 0)
+
+ p.Start()
+ }()
+
+ return p
+}
+
+func (self *Peer) Connect(addr string) (conn net.Conn, err error) {
+ const maxTries = 3
+ for attempts := 0; attempts < maxTries; attempts++ {
+ conn, err = net.DialTimeout("tcp", addr, 10*time.Second)
+ if err != nil {
+ time.Sleep(time.Duration(attempts*20) * time.Second)
+ continue
+ }
+
+ // Success
+ return
+ }
+
+ return
+}
+
+// Getters
+func (p *Peer) PingTime() string {
+ return p.pingTime.String()
+}
+func (p *Peer) Inbound() bool {
+ return p.inbound
+}
+func (p *Peer) LastSend() time.Time {
+ return p.lastSend
+}
+func (p *Peer) LastPong() int64 {
+ return p.lastPong
+}
+func (p *Peer) Host() []byte {
+ return p.host
+}
+func (p *Peer) Port() uint16 {
+ return p.port
+}
+func (p *Peer) Version() string {
+ return p.version
+}
+func (p *Peer) Connected() *int32 {
+ return &p.connected
+}
+
+// Setters
+func (p *Peer) SetVersion(version string) {
+ p.version = version
+}
+
+// Outputs any RLP encoded data to the peer
+func (p *Peer) QueueMessage(msg *ethwire.Msg) {
+ if atomic.LoadInt32(&p.connected) != 1 {
+ return
+ }
+ p.outputQueue <- msg
+}
+
+func (p *Peer) writeMessage(msg *ethwire.Msg) {
+ // Ignore the write if we're not connected
+ if atomic.LoadInt32(&p.connected) != 1 {
+ return
+ }
+
+ if !p.versionKnown {
+ switch msg.Type {
+ case ethwire.MsgHandshakeTy: // Ok
+ default: // Anything but ack is allowed
+ return
+ }
+ } else {
+ /*
+ if !p.statusKnown {
+ switch msg.Type {
+ case ethwire.MsgStatusTy: // Ok
+ default: // Anything but ack is allowed
+ return
+ }
+ }
+ */
+ }
+
+ peerlogger.DebugDetailf("(%v) <= %v\n", p.conn.RemoteAddr(), formatMessage(msg))
+
+ err := ethwire.WriteMessage(p.conn, msg)
+ if err != nil {
+ peerlogger.Debugln(" Can't send message:", err)
+ // Stop the client if there was an error writing to it
+ p.Stop()
+ return
+ }
+}
+
+// Outbound message handler. Outbound messages are handled here
+func (p *Peer) HandleOutbound() {
+ // The ping timer. Makes sure that every 2 minutes a ping is send to the peer
+ pingTimer := time.NewTicker(pingPongTimer)
+ serviceTimer := time.NewTicker(10 * time.Second)
+
+out:
+ for {
+ skip:
+ select {
+ // Main message queue. All outbound messages are processed through here
+ case msg := <-p.outputQueue:
+ if !p.statusKnown {
+ switch msg.Type {
+ case ethwire.MsgTxTy, ethwire.MsgGetBlockHashesTy, ethwire.MsgBlockHashesTy, ethwire.MsgGetBlocksTy, ethwire.MsgBlockTy:
+ break skip
+ }
+ }
+
+ p.writeMessage(msg)
+ p.lastSend = time.Now()
+
+ // Ping timer
+ case <-pingTimer.C:
+ /*
+ timeSince := time.Since(time.Unix(p.lastPong, 0))
+ if !p.pingStartTime.IsZero() && p.lastPong != 0 && timeSince > (pingPongTimer+30*time.Second) {
+ peerlogger.Infof("Peer did not respond to latest pong fast enough, it took %s, disconnecting.\n", timeSince)
+ p.Stop()
+ return
+ }
+ */
+ p.writeMessage(ethwire.NewMessage(ethwire.MsgPingTy, ""))
+ p.pingStartTime = time.Now()
+
+ // Service timer takes care of peer broadcasting, transaction
+ // posting or block posting
+ case <-serviceTimer.C:
+ p.QueueMessage(ethwire.NewMessage(ethwire.MsgGetPeersTy, ""))
+
+ case <-p.quit:
+ // Break out of the for loop if a quit message is posted
+ break out
+ }
+ }
+
+clean:
+ // This loop is for draining the output queue and anybody waiting for us
+ for {
+ select {
+ case <-p.outputQueue:
+ // TODO
+ default:
+ break clean
+ }
+ }
+}
+
+func formatMessage(msg *ethwire.Msg) (ret string) {
+ ret = fmt.Sprintf("%v %v", msg.Type, msg.Data)
+
+ /*
+ XXX Commented out because I need the log level here to determine
+ if i should or shouldn't generate this message
+ */
+ /*
+ switch msg.Type {
+ case ethwire.MsgPeersTy:
+ ret += fmt.Sprintf("(%d entries)", msg.Data.Len())
+ case ethwire.MsgBlockTy:
+ b1, b2 := ethchain.NewBlockFromRlpValue(msg.Data.Get(0)), ethchain.NewBlockFromRlpValue(msg.Data.Get(msg.Data.Len()-1))
+ ret += fmt.Sprintf("(%d entries) %x - %x", msg.Data.Len(), b1.Hash()[0:4], b2.Hash()[0:4])
+ case ethwire.MsgBlockHashesTy:
+ h1, h2 := msg.Data.Get(0).Bytes(), msg.Data.Get(msg.Data.Len()-1).Bytes()
+ ret += fmt.Sprintf("(%d entries) %x - %x", msg.Data.Len(), h1, h2)
+ }
+ */
+
+ return
+}
+
+// Inbound handler. Inbound messages are received here and passed to the appropriate methods
+func (p *Peer) HandleInbound() {
+ for atomic.LoadInt32(&p.disconnect) == 0 {
+
+ // HMM?
+ time.Sleep(50 * time.Millisecond)
+ // Wait for a message from the peer
+ msgs, err := ethwire.ReadMessages(p.conn)
+ if err != nil {
+ peerlogger.Debugln(err)
+ }
+ for _, msg := range msgs {
+ peerlogger.DebugDetailf("(%v) => %v\n", p.conn.RemoteAddr(), formatMessage(msg))
+
+ switch msg.Type {
+ case ethwire.MsgHandshakeTy:
+ // Version message
+ p.handleHandshake(msg)
+
+ //if p.caps.IsCap(CapPeerDiscTy) {
+ p.QueueMessage(ethwire.NewMessage(ethwire.MsgGetPeersTy, ""))
+ //}
+
+ case ethwire.MsgDiscTy:
+ p.Stop()
+ peerlogger.Infoln("Disconnect peer: ", DiscReason(msg.Data.Get(0).Uint()))
+ case ethwire.MsgPingTy:
+ // Respond back with pong
+ p.QueueMessage(ethwire.NewMessage(ethwire.MsgPongTy, ""))
+ case ethwire.MsgPongTy:
+ // If we received a pong back from a peer we set the
+ // last pong so the peer handler knows this peer is still
+ // active.
+ p.lastPong = time.Now().Unix()
+ p.pingTime = time.Since(p.pingStartTime)
+ case ethwire.MsgTxTy:
+ // If the message was a transaction queue the transaction
+ // in the TxPool where it will undergo validation and
+ // processing when a new block is found
+ for i := 0; i < msg.Data.Len(); i++ {
+ tx := ethchain.NewTransactionFromValue(msg.Data.Get(i))
+ p.ethereum.TxPool().QueueTransaction(tx)
+ }
+ case ethwire.MsgGetPeersTy:
+ // Peer asked for list of connected peers
+ //p.pushPeers()
+ case ethwire.MsgPeersTy:
+ // Received a list of peers (probably because MsgGetPeersTy was send)
+ data := msg.Data
+ // Create new list of possible peers for the ethereum to process
+ peers := make([]string, data.Len())
+ // Parse each possible peer
+ for i := 0; i < data.Len(); i++ {
+ value := data.Get(i)
+ peers[i] = unpackAddr(value.Get(0), value.Get(1).Uint())
+ }
+
+ // Connect to the list of peers
+ p.ethereum.ProcessPeerList(peers)
+
+ case ethwire.MsgStatusTy:
+ // Handle peer's status msg
+ p.handleStatus(msg)
+ }
+
+ // TMP
+ if p.statusKnown {
+ switch msg.Type {
+ /*
+ case ethwire.MsgGetTxsTy:
+ // Get the current transactions of the pool
+ txs := p.ethereum.TxPool().CurrentTransactions()
+ // Get the RlpData values from the txs
+ txsInterface := make([]interface{}, len(txs))
+ for i, tx := range txs {
+ txsInterface[i] = tx.RlpData()
+ }
+ // Broadcast it back to the peer
+ p.QueueMessage(ethwire.NewMessage(ethwire.MsgTxTy, txsInterface))
+ */
+
+ case ethwire.MsgGetBlockHashesTy:
+ if msg.Data.Len() < 2 {
+ peerlogger.Debugln("err: argument length invalid ", msg.Data.Len())
+ }
+
+ hash := msg.Data.Get(0).Bytes()
+ amount := msg.Data.Get(1).Uint()
+
+ hashes := p.ethereum.ChainManager().GetChainHashesFromHash(hash, amount)
+
+ p.QueueMessage(ethwire.NewMessage(ethwire.MsgBlockHashesTy, ethutil.ByteSliceToInterface(hashes)))
+
+ case ethwire.MsgGetBlocksTy:
+ // Limit to max 300 blocks
+ max := int(math.Min(float64(msg.Data.Len()), 300.0))
+ var blocks []interface{}
+
+ for i := 0; i < max; i++ {
+ hash := msg.Data.Get(i).Bytes()
+ block := p.ethereum.ChainManager().GetBlock(hash)
+ if block != nil {
+ blocks = append(blocks, block.Value().Raw())
+ }
+ }
+
+ p.QueueMessage(ethwire.NewMessage(ethwire.MsgBlockTy, blocks))
+
+ case ethwire.MsgBlockHashesTy:
+ p.catchingUp = true
+
+ blockPool := p.ethereum.blockPool
+
+ foundCommonHash := false
+
+ it := msg.Data.NewIterator()
+ for it.Next() {
+ hash := it.Value().Bytes()
+ p.lastReceivedHash = hash
+
+ if blockPool.HasCommonHash(hash) {
+ foundCommonHash = true
+
+ break
+ }
+
+ blockPool.AddHash(hash, p)
+ }
+
+ if !foundCommonHash {
+ //if !p.FetchHashes() {
+ // p.doneFetchingHashes = true
+ //}
+ p.FetchHashes()
+ } else {
+ peerlogger.Infof("Found common hash (%x...)\n", p.lastReceivedHash[0:4])
+ p.doneFetchingHashes = true
+ }
+
+ case ethwire.MsgBlockTy:
+ p.catchingUp = true
+
+ blockPool := p.ethereum.blockPool
+
+ it := msg.Data.NewIterator()
+ for it.Next() {
+ block := ethchain.NewBlockFromRlpValue(it.Value())
+ blockPool.Add(block, p)
+
+ p.lastBlockReceived = time.Now()
+ }
+ case ethwire.MsgNewBlockTy:
+ var (
+ blockPool = p.ethereum.blockPool
+ block = ethchain.NewBlockFromRlpValue(msg.Data.Get(0))
+ td = msg.Data.Get(1).BigInt()
+ )
+
+ if td.Cmp(blockPool.td) > 0 {
+ p.ethereum.blockPool.AddNew(block, p)
+ }
+ }
+
+ }
+ }
+ }
+
+ p.Stop()
+}
+
+func (self *Peer) FetchBlocks(hashes [][]byte) {
+ if len(hashes) > 0 {
+ peerlogger.Debugf("Fetching blocks (%d)\n", len(hashes))
+
+ self.QueueMessage(ethwire.NewMessage(ethwire.MsgGetBlocksTy, ethutil.ByteSliceToInterface(hashes)))
+ }
+}
+
+func (self *Peer) FetchHashes() bool {
+ blockPool := self.ethereum.blockPool
+
+ return blockPool.FetchHashes(self)
+}
+
+func (self *Peer) FetchingHashes() bool {
+ return !self.doneFetchingHashes
+}
+
+// General update method
+func (self *Peer) update() {
+ serviceTimer := time.NewTicker(100 * time.Millisecond)
+
+out:
+ for {
+ select {
+ case <-serviceTimer.C:
+ if self.IsCap("eth") {
+ var (
+ sinceBlock = time.Since(self.lastBlockReceived)
+ )
+
+ if sinceBlock > 5*time.Second {
+ self.catchingUp = false
+ }
+ }
+ case <-self.quit:
+ break out
+ }
+ }
+
+ serviceTimer.Stop()
+}
+
+func (p *Peer) Start() {
+ peerHost, peerPort, _ := net.SplitHostPort(p.conn.LocalAddr().String())
+ servHost, servPort, _ := net.SplitHostPort(p.conn.RemoteAddr().String())
+
+ if p.inbound {
+ p.host, p.port = packAddr(peerHost, peerPort)
+ } else {
+ p.host, p.port = packAddr(servHost, servPort)
+ }
+
+ err := p.pushHandshake()
+ if err != nil {
+ peerlogger.Debugln("Peer can't send outbound version ack", err)
+
+ p.Stop()
+
+ return
+ }
+
+ go p.HandleOutbound()
+ // Run the inbound handler in a new goroutine
+ go p.HandleInbound()
+ // Run the general update handler
+ go p.update()
+
+ // Wait a few seconds for startup and then ask for an initial ping
+ time.Sleep(2 * time.Second)
+ p.writeMessage(ethwire.NewMessage(ethwire.MsgPingTy, ""))
+ p.pingStartTime = time.Now()
+
+}
+
+func (p *Peer) Stop() {
+ p.StopWithReason(DiscRequested)
+}
+
+func (p *Peer) StopWithReason(reason DiscReason) {
+ if atomic.AddInt32(&p.disconnect, 1) != 1 {
+ return
+ }
+
+ // Pre-emptively remove the peer; don't wait for reaping. We already know it's dead if we are here
+ p.ethereum.RemovePeer(p)
+
+ close(p.quit)
+ if atomic.LoadInt32(&p.connected) != 0 {
+ p.writeMessage(ethwire.NewMessage(ethwire.MsgDiscTy, reason))
+ p.conn.Close()
+ }
+}
+
+func (p *Peer) peersMessage() *ethwire.Msg {
+ outPeers := make([]interface{}, len(p.ethereum.InOutPeers()))
+ // Serialise each peer
+ for i, peer := range p.ethereum.InOutPeers() {
+ // Don't return localhost as valid peer
+ if !net.ParseIP(peer.conn.RemoteAddr().String()).IsLoopback() {
+ outPeers[i] = peer.RlpData()
+ }
+ }
+
+ // Return the message to the peer with the known list of connected clients
+ return ethwire.NewMessage(ethwire.MsgPeersTy, outPeers)
+}
+
+// Pushes the list of outbound peers to the client when requested
+func (p *Peer) pushPeers() {
+ p.QueueMessage(p.peersMessage())
+}
+
+func (self *Peer) pushStatus() {
+ msg := ethwire.NewMessage(ethwire.MsgStatusTy, []interface{}{
+ uint32(ProtocolVersion),
+ uint32(NetVersion),
+ self.ethereum.ChainManager().TD,
+ self.ethereum.ChainManager().CurrentBlock.Hash(),
+ self.ethereum.ChainManager().Genesis().Hash(),
+ })
+
+ self.QueueMessage(msg)
+}
+
+func (self *Peer) handleStatus(msg *ethwire.Msg) {
+ c := msg.Data
+
+ var (
+ //protoVersion = c.Get(0).Uint()
+ netVersion = c.Get(1).Uint()
+ td = c.Get(2).BigInt()
+ bestHash = c.Get(3).Bytes()
+ genesis = c.Get(4).Bytes()
+ )
+
+ if bytes.Compare(self.ethereum.ChainManager().Genesis().Hash(), genesis) != 0 {
+ ethlogger.Warnf("Invalid genisis hash %x. Disabling [eth]\n", genesis)
+ return
+ }
+
+ if netVersion != NetVersion {
+ ethlogger.Warnf("Invalid network version %d. Disabling [eth]\n", netVersion)
+ return
+ }
+
+ /*
+ if protoVersion != ProtocolVersion {
+ ethlogger.Warnf("Invalid protocol version %d. Disabling [eth]\n", protoVersion)
+ return
+ }
+ */
+
+ // Get the td and last hash
+ self.td = td
+ self.bestHash = bestHash
+ self.lastReceivedHash = bestHash
+
+ self.statusKnown = true
+
+ // Compare the total TD with the blockchain TD. If remote is higher
+ // fetch hashes from highest TD node.
+ self.FetchHashes()
+
+ ethlogger.Infof("Peer is [eth] capable. (TD = %v ~ %x)", self.td, self.bestHash)
+
+}
+
+func (p *Peer) pushHandshake() error {
+ pubkey := p.ethereum.KeyManager().PublicKey()
+ msg := ethwire.NewMessage(ethwire.MsgHandshakeTy, []interface{}{
+ P2PVersion, []byte(p.version), []interface{}{[]interface{}{"eth", ProtocolVersion}}, p.port, pubkey[1:],
+ })
+
+ p.QueueMessage(msg)
+
+ return nil
+}
+
+func (p *Peer) handleHandshake(msg *ethwire.Msg) {
+ c := msg.Data
+
+ var (
+ p2pVersion = c.Get(0).Uint()
+ clientId = c.Get(1).Str()
+ caps = c.Get(2)
+ port = c.Get(3).Uint()
+ pub = c.Get(4).Bytes()
+ )
+
+ // Check correctness of p2p protocol version
+ if p2pVersion != P2PVersion {
+ fmt.Println(p)
+ peerlogger.Debugf("Invalid P2P version. Require protocol %d, received %d\n", P2PVersion, p2pVersion)
+ p.Stop()
+ return
+ }
+
+ // Handle the pub key (validation, uniqueness)
+ if len(pub) == 0 {
+ peerlogger.Warnln("Pubkey required, not supplied in handshake.")
+ p.Stop()
+ return
+ }
+
+ // Self connect detection
+ pubkey := p.ethereum.KeyManager().PublicKey()
+ if bytes.Compare(pubkey[1:], pub) == 0 {
+ p.Stop()
+
+ return
+ }
+
+ // Check for blacklisting
+ for _, pk := range p.ethereum.blacklist {
+ if bytes.Compare(pk, pub) == 0 {
+ peerlogger.Debugf("Blacklisted peer tried to connect (%x...)\n", pubkey[0:4])
+ p.StopWithReason(DiscBadPeer)
+
+ return
+ }
+ }
+
+ usedPub := 0
+ // This peer is already added to the peerlist so we expect to find a double pubkey at least once
+ eachPeer(p.ethereum.Peers(), func(peer *Peer, e *list.Element) {
+ if bytes.Compare(pub, peer.pubkey) == 0 {
+ usedPub++
+ }
+ })
+
+ if usedPub > 0 {
+ peerlogger.Debugf("Pubkey %x found more then once. Already connected to client.", p.pubkey)
+ p.Stop()
+ return
+ }
+ p.pubkey = pub
+
+ // If this is an inbound connection send an ack back
+ if p.inbound {
+ p.port = uint16(port)
+ }
+
+ p.SetVersion(clientId)
+
+ p.versionKnown = true
+
+ p.ethereum.PushPeer(p)
+ p.ethereum.eventMux.Post(PeerListEvent{p.ethereum.Peers()})
+
+ p.protocolCaps = caps
+
+ it := caps.NewIterator()
+ var capsStrs []string
+ for it.Next() {
+ cap := it.Value().Get(0).Str()
+ ver := it.Value().Get(1).Uint()
+ switch cap {
+ case "eth":
+ if ver != ProtocolVersion {
+ ethlogger.Warnf("Invalid protocol version %d. Disabling [eth]\n", ver)
+ continue
+ }
+ p.pushStatus()
+ }
+
+ capsStrs = append(capsStrs, cap)
+ }
+
+ ethlogger.Infof("Added peer (%s) %d / %d (%v)\n", p.conn.RemoteAddr(), p.ethereum.Peers().Len(), p.ethereum.MaxPeers, capsStrs)
+
+ peerlogger.Debugln(p)
+}
+
+func (self *Peer) IsCap(cap string) bool {
+ capsIt := self.protocolCaps.NewIterator()
+ for capsIt.Next() {
+ if capsIt.Value().Str() == cap {
+ return true
+ }
+ }
+
+ return false
+}
+
+func (self *Peer) Caps() *ethutil.Value {
+ return self.protocolCaps
+}
+
+func (p *Peer) String() string {
+ var strBoundType string
+ if p.inbound {
+ strBoundType = "inbound"
+ } else {
+ strBoundType = "outbound"
+ }
+ var strConnectType string
+ if atomic.LoadInt32(&p.disconnect) == 0 {
+ strConnectType = "connected"
+ } else {
+ strConnectType = "disconnected"
+ }
+
+ return fmt.Sprintf("[%s] (%s) %v %s [%s]", strConnectType, strBoundType, p.conn.RemoteAddr(), p.version, p.caps)
+
+}
+
+func (p *Peer) RlpData() []interface{} {
+ return []interface{}{p.host, p.port, p.pubkey}
+}
+
+func packAddr(address, _port string) (host []byte, port uint16) {
+ p, _ := strconv.Atoi(_port)
+ port = uint16(p)
+
+ h := net.ParseIP(address)
+ if ip := h.To4(); ip != nil {
+ host = []byte(ip)
+ } else {
+ host = []byte(h)
+ }
+
+ return
+}
+
+func unpackAddr(value *ethutil.Value, p uint64) string {
+ host, _ := net.IP(value.Bytes()).MarshalText()
+ prt := strconv.Itoa(int(p))
+
+ return net.JoinHostPort(string(host), prt)
+}
diff --git a/pow/ar/block.go b/pow/ar/block.go
new file mode 100644
index 0000000000000000000000000000000000000000..541092f7e4d587f7b85876f414b5b027c805e17f
--- /dev/null
+++ b/pow/ar/block.go
@@ -0,0 +1,12 @@
+package ar
+
+import (
+ "math/big"
+
+ "github.com/ethereum/go-ethereum/ethtrie"
+)
+
+type Block interface {
+ Trie() *ethtrie.Trie
+ Diff() *big.Int
+}
diff --git a/pow/ar/ops.go b/pow/ar/ops.go
new file mode 100644
index 0000000000000000000000000000000000000000..3a099be0877cee62591ed262d98ca2b1bfd576ee
--- /dev/null
+++ b/pow/ar/ops.go
@@ -0,0 +1,54 @@
+package ar
+
+import "math/big"
+
+const lenops int64 = 9
+
+type OpsFunc func(a, b *big.Int) *big.Int
+
+var ops [lenops]OpsFunc
+
+func init() {
+ ops[0] = Add
+ ops[1] = Mul
+ ops[2] = Mod
+ ops[3] = Xor
+ ops[4] = And
+ ops[5] = Or
+ ops[6] = Sub1
+ ops[7] = XorSub
+ ops[8] = Rsh
+}
+
+func Add(x, y *big.Int) *big.Int {
+ return new(big.Int).Add(x, y)
+}
+func Mul(x, y *big.Int) *big.Int {
+ return new(big.Int).Mul(x, y)
+}
+func Mod(x, y *big.Int) *big.Int {
+ return new(big.Int).Mod(x, y)
+}
+func Xor(x, y *big.Int) *big.Int {
+ return new(big.Int).Xor(x, y)
+}
+func And(x, y *big.Int) *big.Int {
+ return new(big.Int).And(x, y)
+}
+func Or(x, y *big.Int) *big.Int {
+ return new(big.Int).Or(x, y)
+}
+func Sub1(x, y *big.Int) *big.Int {
+ a := big.NewInt(-1)
+ a.Sub(a, x)
+
+ return a
+}
+func XorSub(x, y *big.Int) *big.Int {
+ t := Sub1(x, nil)
+
+ return t.Xor(t, y)
+}
+func Rsh(x, y *big.Int) *big.Int {
+ return new(big.Int).Rsh(x, uint(y.Uint64()%64))
+}
diff --git a/pow/ar/pow.go b/pow/ar/pow.go
new file mode 100644
index 0000000000000000000000000000000000000000..8991a674ba46459fd12447fd20127acdbcb01331
--- /dev/null
+++ b/pow/ar/pow.go
@@ -0,0 +1,122 @@
+package ar
+
+import (
+ "math/big"
+
+ "github.com/ethereum/go-ethereum/ethutil"
+)
+
+type Entry struct {
+ op OpsFunc
+ i, j *big.Int
+}
+
+type Tape struct {
+ tape []Entry
+ block Block
+}
+
+func NewTape(block Block) *Tape {
+ return &Tape{nil, block}
+}
+
+func (self *Tape) gen(w, h int64, gen NumberGenerator) {
+ self.tape = nil
+
+ for v := int64(0); v < h; v++ {
+ op := ops[gen.rand64(lenops).Int64()]
+ r := gen.rand64(100).Uint64()
+
+ var j *big.Int
+ if r < 20 && v > 20 {
+ j = self.tape[len(self.tape)-1].i
+ } else {
+ j = gen.rand64(w)
+ }
+
+ i := gen.rand64(w)
+ self.tape = append(self.tape, Entry{op, i, j})
+ }
+}
+
+func (self *Tape) runTape(w, h int64, gen NumberGenerator) *big.Int {
+ var mem []*big.Int
+ for i := int64(0); i < w; i++ {
+ mem = append(mem, gen.rand(ethutil.BigPow(2, 64)))
+ }
+
+ set := func(i, j int) Entry {
+ entry := self.tape[i*100+j]
+ mem[entry.i.Uint64()] = entry.op(entry.i, entry.j)
+
+ return entry
+ }
+
+ dir := true
+ for i := 0; i < int(h)/100; i++ {
+ var entry Entry
+ if dir {
+ for j := 0; j < 100; j++ {
+ entry = set(i, j)
+ }
+ } else {
+ for j := 99; i >= 0; j-- {
+ entry = set(i, j)
+ }
+ }
+
+ t := mem[entry.i.Uint64()]
+ if big.NewInt(2).Cmp(new(big.Int).Mod(t, big.NewInt(37))) < 0 {
+ dir = !dir
+ }
+ }
+
+ return Sha3(mem)
+}
+
+func (self *Tape) Verify(header, nonce []byte) bool {
+ n := ethutil.BigD(nonce)
+
+ var w int64 = 10000
+ var h int64 = 150000
+ gen := Rnd(Sha3([]interface{}{header, new(big.Int).Div(n, big.NewInt(1000))}))
+ self.gen(w, h, gen)
+
+ gen = Rnd(Sha3([]interface{}{header, new(big.Int).Mod(n, big.NewInt(1000))}))
+ hash := self.runTape(w, h, gen)
+
+ it := self.block.Trie().Iterator()
+ next := it.Next(string(new(big.Int).Mod(hash, ethutil.BigPow(2, 160)).Bytes()))
+
+ req := ethutil.BigPow(2, 256)
+ req.Div(req, self.block.Diff())
+ return Sha3([]interface{}{hash, next}).Cmp(req) < 0
+}
+
+func (self *Tape) Run(header []byte) []byte {
+ nonce := big.NewInt(0)
+ var w int64 = 10000
+ var h int64 = 150000
+
+ req := ethutil.BigPow(2, 256)
+ req.Div(req, self.block.Diff())
+
+ for {
+ if new(big.Int).Mod(nonce, b(1000)).Cmp(b(0)) == 0 {
+ gen := Rnd(Sha3([]interface{}{header, new(big.Int).Div(nonce, big.NewInt(1000))}))
+ self.gen(w, h, gen)
+ }
+
+ gen := Rnd(Sha3([]interface{}{header, new(big.Int).Mod(nonce, big.NewInt(1000))}))
+ hash := self.runTape(w, h, gen)
+
+ it := self.block.Trie().Iterator()
+ next := it.Next(string(new(big.Int).Mod(hash, ethutil.BigPow(2, 160)).Bytes()))
+
+ if Sha3([]interface{}{hash, next}).Cmp(req) < 0 {
+ return nonce.Bytes()
+ } else {
+ nonce.Add(nonce, ethutil.Big1)
+ }
+ }
+}
diff --git a/pow/ar/pow_test.go b/pow/ar/pow_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..3db9659e084787cf5c2deedb81cdf2bec08462e4
--- /dev/null
+++ b/pow/ar/pow_test.go
@@ -0,0 +1,47 @@
+package ar
+
+import (
+ "fmt"
+ "math/big"
+ "testing"
+
+ "github.com/ethereum/go-ethereum/ethdb"
+ "github.com/ethereum/go-ethereum/ethtrie"
+)
+
+type TestBlock struct {
+ trie *ethtrie.Trie
+}
+
+func NewTestBlock() *TestBlock {
+ db, _ := ethdb.NewMemDatabase()
+ return &TestBlock{
+ trie: ethtrie.New(db, ""),
+ }
+}
+
+func (self *TestBlock) Diff() *big.Int {
+ return b(10)
+}
+
+func (self *TestBlock) Trie() *ethtrie.Trie {
+ return self.trie
+}
+
+func (self *TestBlock) Hash() []byte {
+ a := make([]byte, 32)
+ a[0] = 10
+ a[1] = 2
+ return a
+}
+
+func TestPow(t *testing.T) {
+ entry := make([]byte, 32)
+ entry[0] = 255
+
+ block := NewTestBlock()
+
+ pow := NewTape(block)
+ nonce := pow.Run(block.Hash())
+ fmt.Println("Found nonce", nonce)
+}
diff --git a/pow/ar/rnd.go b/pow/ar/rnd.go
new file mode 100644
index 0000000000000000000000000000000000000000..7dbd99373eb94e4aa80eb243b60c9fff0736684e
--- /dev/null
+++ b/pow/ar/rnd.go
@@ -0,0 +1,66 @@
+package ar
+
+import (
+ "math/big"
+
+ "github.com/ethereum/go-ethereum/ethcrypto"
+ "github.com/ethereum/go-ethereum/ethutil"
+)
+
+var b = big.NewInt
+
+type Node interface {
+ Big() *big.Int
+}
+
+type ByteNode []byte
+
+func (self ByteNode) Big() *big.Int {
+ return ethutil.BigD(ethutil.Encode([]byte(self)))
+}
+
+func Sha3(v interface{}) *big.Int {
+ if b, ok := v.(*big.Int); ok {
+ return ethutil.BigD(ethcrypto.Sha3(b.Bytes()))
+ } else if b, ok := v.([]interface{}); ok {
+ return ethutil.BigD(ethcrypto.Sha3(ethutil.Encode(b)))
+ } else if s, ok := v.([]*big.Int); ok {
+ v := make([]interface{}, len(s))
+ for i, b := range s {
+ v[i] = b
+ }
+
+ return ethutil.BigD(ethcrypto.Sha3(ethutil.Encode(v)))
+ }
+
+ return nil
+}
+
+type NumberGenerator interface {
+ rand(r *big.Int) *big.Int
+ rand64(r int64) *big.Int
+}
+
+type rnd struct {
+ seed *big.Int
+}
+
+func Rnd(s *big.Int) rnd {
+ return rnd{s}
+}
+
+func (self rnd) rand(r *big.Int) *big.Int {
+ o := b(0).Mod(self.seed, r)
+
+ self.seed.Div(self.seed, r)
+
+ if self.seed.Cmp(ethutil.BigPow(2, 64)) < 0 {
+ self.seed = Sha3(self.seed)
+ }
+
+ return o
+}
+
+func (self rnd) rand64(r int64) *big.Int {
+ return self.rand(b(r))
+}
diff --git a/rpc/json.go b/rpc/json.go
new file mode 100644
index 0000000000000000000000000000000000000000..e467f9a342ae1ca1b8d5a9e067a625e7f17040d1
--- /dev/null
+++ b/rpc/json.go
@@ -0,0 +1,20 @@
+package rpc
+
+import (
+ "encoding/json"
+ "io"
+)
+
+type jsonWrapper struct{}
+
+func (self jsonWrapper) Send(writer io.Writer, v interface{}) (n int, err error) {
+ var payload []byte
+ payload, err = json.Marshal(v)
+ if err != nil {
+ return 0, err
+ }
+
+ return writer.Write(payload)
+}
+
+var JSON jsonWrapper
diff --git a/rpc/message.go b/rpc/message.go
new file mode 100644
index 0000000000000000000000000000000000000000..c8103eded624ece98bce1d1b07065cd22732bf98
--- /dev/null
+++ b/rpc/message.go
@@ -0,0 +1,14 @@
+package rpc
+
+import "github.com/ethereum/go-ethereum/ethutil"
+
+type Message struct {
+ Call string `json:"call"`
+ Args []interface{} `json:"args"`
+ Id int `json:"_id"`
+ Data interface{} `json:"data"`
+}
+
+func (self *Message) Arguments() *ethutil.Value {
+ return ethutil.NewValue(self.Args)
+}
diff --git a/rpc/packages.go b/rpc/packages.go
new file mode 100644
index 0000000000000000000000000000000000000000..07d3ddc9a2f43725b0c63af94504f78f8c990372
--- /dev/null
+++ b/rpc/packages.go
@@ -0,0 +1,311 @@
+package rpc
+
+import (
+ "encoding/json"
+ "errors"
+ "math/big"
+ "strings"
+
+ "github.com/ethereum/go-ethereum/ethpipe"
+ "github.com/ethereum/go-ethereum/ethutil"
+)
+
+type EthereumApi struct {
+ pipe *ethpipe.JSPipe
+}
+
+type JsonArgs interface {
+ requirements() error
+}
+
+type BlockResponse struct {
+ JsonResponse
+}
+type GetBlockArgs struct {
+ BlockNumber int
+ Hash string
+}
+
+type ErrorResponse struct {
+ Error bool `json:"error"`
+ ErrorText string `json:"errorText"`
+}
+
+type JsonResponse interface {
+}
+
+type SuccessRes struct {
+ Error bool `json:"error"`
+ Result JsonResponse `json:"result"`
+}
+
+func NewSuccessRes(object JsonResponse) string {
+ e := SuccessRes{Error: false, Result: object}
+ res, err := json.Marshal(e)
+ if err != nil {
+ // This should never happen
+ panic("Creating json error response failed, help")
+ }
+ success := string(res)
+ return success
+}
+
+func NewErrorResponse(msg string) error {
+ e := ErrorResponse{Error: true, ErrorText: msg}
+ res, err := json.Marshal(e)
+ if err != nil {
+ // This should never happen
+ panic("Creating json error response failed, help")
+ }
+ newErr := errors.New(string(res))
+ return newErr
+}
+
+func (b *GetBlockArgs) requirements() error {
+ if b.BlockNumber == 0 && b.Hash == "" {
+ return NewErrorResponse("GetBlock requires either a block 'number' or a block 'hash' as argument")
+ }
+ return nil
+}
+
+func (p *EthereumApi) GetBlock(args *GetBlockArgs, reply *string) error {
+ err := args.requirements()
+ if err != nil {
+ return err
+ }
+
+ block := p.pipe.BlockByHash(args.Hash)
+ *reply = NewSuccessRes(block)
+ return nil
+}
+
+type NewTxArgs struct {
+ Sec string
+ Recipient string
+ Value string
+ Gas string
+ GasPrice string
+ Init string
+ Body string
+}
+type TxResponse struct {
+ Hash string
+}
+
+func (a *NewTxArgs) requirements() error {
+ if a.Recipient == "" {
+ return NewErrorResponse("Transact requires a 'recipient' address as argument")
+ }
+ if a.Value == "" {
+ return NewErrorResponse("Transact requires a 'value' as argument")
+ }
+ if a.Gas == "" {
+ return NewErrorResponse("Transact requires a 'gas' value as argument")
+ }
+ if a.GasPrice == "" {
+ return NewErrorResponse("Transact requires a 'gasprice' value as argument")
+ }
+ return nil
+}
+
+func (a *NewTxArgs) requirementsContract() error {
+ if a.Value == "" {
+ return NewErrorResponse("Create requires a 'value' as argument")
+ }
+ if a.Gas == "" {
+ return NewErrorResponse("Create requires a 'gas' value as argument")
+ }
+ if a.GasPrice == "" {
+ return NewErrorResponse("Create requires a 'gasprice' value as argument")
+ }
+ if a.Body == "" {
+ return NewErrorResponse("Create requires a 'body' value as argument")
+ }
+ return nil
+}
+
+func (p *EthereumApi) Transact(args *NewTxArgs, reply *string) error {
+ err := args.requirements()
+ if err != nil {
+ return err
+ }
+ result, _ := p.pipe.Transact(p.pipe.Key().PrivateKey, args.Recipient, args.Value, args.Gas, args.GasPrice, args.Body)
+ *reply = NewSuccessRes(result)
+ return nil
+}
+
+func (p *EthereumApi) Create(args *NewTxArgs, reply *string) error {
+ err := args.requirementsContract()
+ if err != nil {
+ return err
+ }
+
+ result, _ := p.pipe.Transact(p.pipe.Key().PrivateKey, "", args.Value, args.Gas, args.GasPrice, args.Body)
+ *reply = NewSuccessRes(result)
+ return nil
+}
+
+type PushTxArgs struct {
+ Tx string
+}
+
+func (a *PushTxArgs) requirementsPushTx() error {
+ if a.Tx == "" {
+ return NewErrorResponse("PushTx requires a 'tx' as argument")
+ }
+ return nil
+}
+
+func (p *EthereumApi) PushTx(args *PushTxArgs, reply *string) error {
+ err := args.requirementsPushTx()
+ if err != nil {
+ return err
+ }
+ result, _ := p.pipe.PushTx(args.Tx)
+ *reply = NewSuccessRes(result)
+ return nil
+}
+
+func (p *EthereumApi) GetKey(args interface{}, reply *string) error {
+ *reply = NewSuccessRes(p.pipe.Key())
+ return nil
+}
+
+type GetStorageArgs struct {
+ Address string
+ Key string
+}
+
+func (a *GetStorageArgs) requirements() error {
+ if a.Address == "" {
+ return NewErrorResponse("GetStorageAt requires an 'address' value as argument")
+ }
+ if a.Key == "" {
+ return NewErrorResponse("GetStorageAt requires an 'key' value as argument")
+ }
+ return nil
+}
+
+type GetStorageAtRes struct {
+ Key string `json:"key"`
+ Value string `json:"value"`
+ Address string `json:"address"`
+}
+
+func (p *EthereumApi) GetStorageAt(args *GetStorageArgs, reply *string) error {
+ err := args.requirements()
+ if err != nil {
+ return err
+ }
+
+ state := p.pipe.World().SafeGet(ethutil.Hex2Bytes(args.Address))
+
+ var hx string
+ if strings.Index(args.Key, "0x") == 0 {
+ hx = string([]byte(args.Key)[2:])
+ } else {
+ // Convert the incoming string (which is a bigint) into hex
+ i, _ := new(big.Int).SetString(args.Key, 10)
+ hx = ethutil.Bytes2Hex(i.Bytes())
+ }
+ logger.Debugf("GetStorageAt(%s, %s)\n", args.Address, hx)
+ value := state.Storage(ethutil.Hex2Bytes(hx))
+ *reply = NewSuccessRes(GetStorageAtRes{Address: args.Address, Key: args.Key, Value: value.Str()})
+ return nil
+}
+
+type GetTxCountArgs struct {
+ Address string `json:"address"`
+}
+type GetTxCountRes struct {
+ Nonce int `json:"nonce"`
+}
+
+func (a *GetTxCountArgs) requirements() error {
+ if a.Address == "" {
+ return NewErrorResponse("GetTxCountAt requires an 'address' value as argument")
+ }
+ return nil
+}
+
+type GetPeerCountRes struct {
+ PeerCount int `json:"peerCount"`
+}
+
+func (p *EthereumApi) GetPeerCount(args *interface{}, reply *string) error {
+ *reply = NewSuccessRes(GetPeerCountRes{PeerCount: p.pipe.PeerCount()})
+ return nil
+}
+
+type GetListeningRes struct {
+ IsListening bool `json:"isListening"`
+}
+
+func (p *EthereumApi) GetIsListening(args *interface{}, reply *string) error {
+ *reply = NewSuccessRes(GetListeningRes{IsListening: p.pipe.IsListening()})
+ return nil
+}
+
+type GetCoinbaseRes struct {
+ Coinbase string `json:"coinbase"`
+}
+
+func (p *EthereumApi) GetCoinbase(args *interface{}, reply *string) error {
+ *reply = NewSuccessRes(GetCoinbaseRes{Coinbase: p.pipe.CoinBase()})
+ return nil
+}
+
+type GetMiningRes struct {
+ IsMining bool `json:"isMining"`
+}
+
+func (p *EthereumApi) GetIsMining(args *interface{}, reply *string) error {
+ *reply = NewSuccessRes(GetMiningRes{IsMining: p.pipe.IsMining()})
+ return nil
+}
+
+func (p *EthereumApi) GetTxCountAt(args *GetTxCountArgs, reply *string) error {
+ err := args.requirements()
+ if err != nil {
+ return err
+ }
+ state := p.pipe.TxCountAt(args.Address)
+ *reply = NewSuccessRes(GetTxCountRes{Nonce: state})
+ return nil
+}
+
+type GetBalanceArgs struct {
+ Address string
+}
+
+func (a *GetBalanceArgs) requirements() error {
+ if a.Address == "" {
+ return NewErrorResponse("GetBalanceAt requires an 'address' value as argument")
+ }
+ return nil
+}
+
+type BalanceRes struct {
+ Balance string `json:"balance"`
+ Address string `json:"address"`
+}
+
+func (p *EthereumApi) GetBalanceAt(args *GetBalanceArgs, reply *string) error {
+ err := args.requirements()
+ if err != nil {
+ return err
+ }
+ state := p.pipe.World().SafeGet(ethutil.Hex2Bytes(args.Address))
+ *reply = NewSuccessRes(BalanceRes{Balance: state.Balance().String(), Address: args.Address})
+ return nil
+}
+
+type TestRes struct {
+ JsonResponse `json:"-"`
+ Answer int `json:"answer"`
+}
+
+func (p *EthereumApi) Test(args *GetBlockArgs, reply *string) error {
+ *reply = NewSuccessRes(TestRes{Answer: 15})
+ return nil
+}
diff --git a/rpc/server.go b/rpc/server.go
new file mode 100644
index 0000000000000000000000000000000000000000..ce53266f0594aed3098534e531dffde318eca24d
--- /dev/null
+++ b/rpc/server.go
@@ -0,0 +1,67 @@
+package rpc
+
+import (
+ "fmt"
+ "net"
+ "net/rpc"
+ "net/rpc/jsonrpc"
+
+ "github.com/ethereum/go-ethereum/ethlog"
+ "github.com/ethereum/go-ethereum/ethpipe"
+)
+
+var logger = ethlog.NewLogger("JSON")
+
+type JsonRpcServer struct {
+ quit chan bool
+ listener net.Listener
+ pipe *ethpipe.JSPipe
+}
+
+func (s *JsonRpcServer) exitHandler() {
+out:
+ for {
+ select {
+ case <-s.quit:
+ s.listener.Close()
+ break out
+ }
+ }
+
+ logger.Infoln("Shutdown JSON-RPC server")
+}
+
+func (s *JsonRpcServer) Stop() {
+ close(s.quit)
+}
+
+func (s *JsonRpcServer) Start() {
+ logger.Infoln("Starting JSON-RPC server")
+ go s.exitHandler()
+ rpc.Register(&EthereumApi{pipe: s.pipe})
+ rpc.HandleHTTP()
+
+ for {
+ conn, err := s.listener.Accept()
+ if err != nil {
+ logger.Infoln("Error starting JSON-RPC:", err)
+ break
+ }
+ logger.Debugln("Incoming request.")
+ go jsonrpc.ServeConn(conn)
+ }
+}
+
+func NewJsonRpcServer(pipe *ethpipe.JSPipe, port int) (*JsonRpcServer, error) {
+ sport := fmt.Sprintf(":%d", port)
+ l, err := net.Listen("tcp", sport)
+ if err != nil {
+ return nil, err
+ }
+
+ return &JsonRpcServer{
+ listener: l,
+ quit: make(chan bool),
+ pipe: pipe,
+ }, nil
+}
diff --git a/rpc/writer.go b/rpc/writer.go
new file mode 100644
index 0000000000000000000000000000000000000000..4cc39f577053a8d7bab71349ef200ad73fe4b16b
--- /dev/null
+++ b/rpc/writer.go
@@ -0,0 +1,75 @@
+package rpc
+
+/*
+func pack(id int, v ...interface{}) Message {
+ return Message{Data: v, Id: id}
+}
+
+func WriteOn(msg *Message, writer io.Writer) {
+ //msg := &Message{Seed: seed, Data: data}
+
+ switch msg.Call {
+ case "compile":
+ data := ethutil.NewValue(msg.Args)
+ bcode, err := ethutil.Compile(data.Get(0).Str(), false)
+ if err != nil {
+ JSON.Send(writer, pack(msg.Id, err.Error()))
+ }
+
+ code := ethutil.Bytes2Hex(bcode)
+
+ JSON.Send(writer, pack(msg.Id, code, nil))
+ case "block":
+ args := msg.Arguments()
+
+ block := pipe.BlockByNumber(int32(args.Get(0).Uint()))
+
+ JSON.Send(writer, pack(msg.Id, block))
+ case "transact":
+ if mp, ok := msg.Args[0].(map[string]interface{}); ok {
+ object := mapToTxParams(mp)
+ JSON.Send(
+ writer,
+ pack(msg.Id, args(pipe.Transact(object["from"], object["to"], object["value"], object["gas"], object["gasPrice"], object["data"]))),
+ )
+
+ }
+ case "coinbase":
+ JSON.Send(writer, pack(msg.Id, pipe.CoinBase(), msg.Seed))
+
+ case "listening":
+ JSON.Send(writer, pack(msg.Id, pipe.IsListening()))
+
+ case "mining":
+ JSON.Send(writer, pack(msg.Id, pipe.IsMining()))
+
+ case "peerCoint":
+ JSON.Send(writer, pack(msg.Id, pipe.PeerCount()))
+
+ case "countAt":
+ args := msg.Arguments()
+
+ JSON.Send(writer, pack(msg.Id, pipe.TxCountAt(args.Get(0).Str())))
+
+ case "codeAt":
+ args := msg.Arguments()
+
+ JSON.Send(writer, pack(msg.Id, len(pipe.CodeAt(args.Get(0).Str()))))
+
+ case "stateAt":
+ args := msg.Arguments()
+
+ JSON.Send(writer, pack(msg.Id, pipe.StorageAt(args.Get(0).Str(), args.Get(1).Str())))
+
+ case "balanceAt":
+ args := msg.Arguments()
+
+ JSON.Send(writer, pack(msg.Id, pipe.BalanceAt(args.Get(0).Str())))
+
+ case "newFilter":
+ case "newFilterString":
+ case "messages":
+ // TODO
+ }
+}
+*/
diff --git a/tests/ethtest/.ethtest b/tests/ethtest/.ethtest
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/tests/ethtest/main.go b/tests/ethtest/main.go
new file mode 100644
index 0000000000000000000000000000000000000000..fb423cbd0cc5820bebe65cf245505702b52235dc
--- /dev/null
+++ b/tests/ethtest/main.go
@@ -0,0 +1,105 @@
+package main
+
+import (
+ "bytes"
+ "encoding/json"
+ "io/ioutil"
+ "log"
+ "os"
+ "strings"
+
+ "github.com/ethereum/go-ethereum/ethstate"
+ "github.com/ethereum/go-ethereum/ethutil"
+ "github.com/ethereum/go-ethereum/tests/helper"
+)
+
+type Account struct {
+ Balance string
+ Code string
+ Nonce string
+ Storage map[string]string
+}
+
+func StateObjectFromAccount(addr string, account Account) *ethstate.StateObject {
+ obj := ethstate.NewStateObject(ethutil.Hex2Bytes(addr))
+ obj.SetBalance(ethutil.Big(account.Balance))
+
+ if ethutil.IsHex(account.Code) {
+ account.Code = account.Code[2:]
+ }
+ obj.Code = ethutil.Hex2Bytes(account.Code)
+ obj.Nonce = ethutil.Big(account.Nonce).Uint64()
+
+ return obj
+}
+
+type VmTest struct {
+ Callcreates interface{}
+ Env map[string]string
+ Exec map[string]string
+ Gas string
+ Out string
+ Post map[string]Account
+ Pre map[string]Account
+}
+
+func RunVmTest(js string) (failed int) {
+ tests := make(map[string]VmTest)
+
+ data, _ := ioutil.ReadAll(strings.NewReader(js))
+ err := json.Unmarshal(data, &tests)
+ if err != nil {
+ log.Fatalln(err)
+ }
+
+ for name, test := range tests {
+ state := ethstate.New(helper.NewTrie())
+ for addr, account := range test.Pre {
+ obj := StateObjectFromAccount(addr, account)
+ state.SetStateObject(obj)
+ }
+
+ ret, gas, err := helper.RunVm(state, test.Env, test.Exec)
+ // When an error is returned it doesn't always mean the tests fails.
+ // Have to come up with some conditional failing mechanism.
+ if err != nil {
+ log.Println(err)
+ }
+
+ rexp := helper.FromHex(test.Out)
+ if bytes.Compare(rexp, ret) != 0 {
+ log.Printf("%s's return failed. Expected %x, got %x\n", name, rexp, ret)
+ failed = 1
+ }
+
+ gexp := ethutil.Big(test.Gas)
+ if gexp.Cmp(gas) != 0 {
+ log.Printf("%s's gas failed. Expected %v, got %v\n", name, gexp, gas)
+ failed = 1
+ }
+
+ for addr, account := range test.Post {
+ obj := state.GetStateObject(helper.FromHex(addr))
+ for addr, value := range account.Storage {
+ v := obj.GetState(helper.FromHex(addr)).Bytes()
+ vexp := helper.FromHex(value)
+
+ if bytes.Compare(v, vexp) != 0 {
+ log.Printf("%s's : (%x: %s) storage failed. Expected %x, got %x (%v %v)\n", name, obj.Address()[0:4], addr, vexp, v, ethutil.BigD(vexp), ethutil.BigD(v))
+ failed = 1
+ }
+ }
+ }
+ }
+
+ return
+}
+
+func main() {
+ helper.Logger.SetLogLevel(5)
+ if len(os.Args) == 1 {
+ log.Fatalln("no json supplied")
+ }
+
+ os.Exit(RunVmTest(os.Args[1]))
+}
diff --git a/tests/ethtest/vmArithmeticTest.json b/tests/ethtest/vmArithmeticTest.json
new file mode 100644
index 0000000000000000000000000000000000000000..5df9965b761cba45c2756ccaf57d4cc56dc943f0
--- /dev/null
+++ b/tests/ethtest/vmArithmeticTest.json
@@ -0,0 +1,3239 @@
+{
+ "add0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff01600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff01600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff01600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "add1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x60047fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff01600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60047fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff01600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x03"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60047fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff01600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "add2" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "10000",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "add3" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6000600001600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9896",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6000600001600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6000600001600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "add4" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff600101600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9896",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff600101600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff600101600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "divByNonZero0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6002600504600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6002600504600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x02"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6002600504600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "divByNonZero1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6018601704600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9896",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6018601704600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6018601704600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "divByNonZero2" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6018600004600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9896",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6018600004600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6018600004600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "divByNonZero3" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6001600104600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6001600104600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6001600104600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "divByZero" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6000600204600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9896",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6000600204600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6000600204600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "eq0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600360000360056000030e600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9892",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600360000360056000030e600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600360000360056000030e600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "eq1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600060000e600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600060000e600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600060000e600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "eq2" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0e600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0e600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0e600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "exp0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6002600208600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6002600208600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x04"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6002600208600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "exp1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff08600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff08600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff08600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "exp2" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x637fffffff637fffffff08600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x637fffffff637fffffff08600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0xbc8cccccccc888888880000000aaaaaab00000000fffffffffffffff7fffffff"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x637fffffff637fffffff08600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "exp3" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x637fffffff600008600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9896",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x637fffffff600008600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x637fffffff600008600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "exp4" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6000637fffffff08600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6000637fffffff08600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6000637fffffff08600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "exp5" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600161010108600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600161010108600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x0101"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600161010108600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "exp6" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x610101600108600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x610101600108600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x610101600108600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "exp7" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x610101600208600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9896",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x610101600208600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x610101600208600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "gt0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600060026000030b600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9794",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600060026000030b600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600060026000030b600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "gt1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600260000360000b600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9894",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600260000360000b600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600260000360000b600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "gt2" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0b600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0b600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0b600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "gt3" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60000b600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9896",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60000b600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60000b600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "lt0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600060026000030a600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9894",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600060026000030a600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600060026000030a600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "lt1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600260000360000a600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9794",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600260000360000a600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600260000360000a600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "lt2" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0a600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9896",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0a600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0a600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "lt3" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60000a600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60000a600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60000a600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "mod0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6003600206600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6003600206600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x02"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6003600206600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "mod1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x60027fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff06600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60027fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff06600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60027fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff06600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "mod2" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff600006600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9896",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff600006600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff600006600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "mod3" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6000600306600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9896",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6000600306600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6000600306600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "mod4" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6003600260000306600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9794",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6003600260000306600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x02"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6003600260000306600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "mul0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6003600202600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6003600202600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x06"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6003600202600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "mul1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff02600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff02600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff02600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "mul2" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6017600002600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9896",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6017600002600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6017600002600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "mul3" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6001601702600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6001601702600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x17"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6001601702600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "mul4" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f800000000000000000000000000000000000000000000000000000000000000002600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f800000000000000000000000000000000000000000000000000000000000000002600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x8000000000000000000000000000000000000000000000000000000000000000"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f800000000000000000000000000000000000000000000000000000000000000002600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "mul5" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7f80000000000000000000000000000000000000000000000000000000000000007f800000000000000000000000000000000000000000000000000000000000000002600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9896",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7f80000000000000000000000000000000000000000000000000000000000000007f800000000000000000000000000000000000000000000000000000000000000002600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7f80000000000000000000000000000000000000000000000000000000000000007f800000000000000000000000000000000000000000000000000000000000000002600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "mul6" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7f7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff02600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7f7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff02600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7f7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff02600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "neg0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600009600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9897",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600009600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600009600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "neg1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600209600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9797",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600209600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600209600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "neg2" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff09600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9797",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff09600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff09600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "neg3" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600260000309600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9795",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600260000309600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x02"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600260000309600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "neg4" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60000309600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9795",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60000309600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60000309600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "neg5" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600060000309600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9895",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600060000309600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600060000309600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "not0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0f600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9897",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0f600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0f600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "not1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x60000f600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9797",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60000f600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60000f600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "sdiv0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60000305600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9794",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60000305600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60000305600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "sdiv1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff6000037fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff05600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9794",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff6000037fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff05600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff6000037fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff05600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "sdiv2" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6004600003600260000305600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9892",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6004600003600260000305600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6004600003600260000305600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "sdiv3" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6002600003600405600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9794",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6002600003600405600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6002600003600405600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "sdivByZero0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6000600003600360000305600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9892",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6000600003600360000305600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6000600003600360000305600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "sdivByZero1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60000305600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9894",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60000305600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60000305600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "sgt0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600060026000030d600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9894",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600060026000030d600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600060026000030d600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "sgt1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600260000360000d600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9794",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600260000360000d600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600260000360000d600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "sgt2" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0d600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9896",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0d600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0d600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "sgt3" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60000d600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60000d600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60000d600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "sgt4" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600360000360056000030d600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9892",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600360000360056000030d600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600360000360056000030d600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "slt0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600060026000030c600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9794",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600060026000030c600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600060026000030c600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "slt1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600260000360000c600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9894",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600260000360000c600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600260000360000c600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "slt2" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0c600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0c600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0c600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "slt3" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60000c600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9896",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60000c600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60000c600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "slt4" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600360000360056000030c600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9792",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600360000360056000030c600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600360000360056000030c600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "smod0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6003600003600560000307600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9792",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6003600003600560000307600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6003600003600560000307600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "smod1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6003600003600507600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9794",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6003600003600507600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x02"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6003600003600507600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "smod2" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6003600560000307600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9794",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6003600560000307600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6003600560000307600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "smod3" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff600260000307600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9894",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff600260000307600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff600260000307600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "smod4" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6000600260000307600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9894",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6000600260000307600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6000600260000307600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "stop" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x00",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "10000",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x00",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x00",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "sub0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6001601703600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6001601703600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x16"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6001601703600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "sub1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6003600203600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6003600203600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6003600203600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "sub2" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6017600003600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6017600003600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe9"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6017600003600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "sub3" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff600003600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff600003600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff600003600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "sub4" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff03600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff03600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff03600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/tests/files/README.md b/tests/files/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..0f7dbe5a6b4055363bc19b9d9a47c82b3ca62e16
--- /dev/null
+++ b/tests/files/README.md
@@ -0,0 +1,26 @@
+tests
+=====
+
+Common tests for all clients to test against.
+
+All files should be of the form:
+
+```
+{
+ "test1name":
+ {
+ "test1property1": ...,
+ "test1property2": ...,
+ ...
+ },
+ "test2name":
+ {
+ "test2property1": ...,
+ "test2property2": ...,
+ ...
+ }
+}
+```
+
+Arrays are allowed, but don't use them for sets of properties - only use them for data that is clearly a continuous contiguous sequence of values.
+
diff --git a/tests/files/TODO b/tests/files/TODO
new file mode 100644
index 0000000000000000000000000000000000000000..91d0f358b5705fbd843b7340c22351dbdd008a51
--- /dev/null
+++ b/tests/files/TODO
@@ -0,0 +1,21 @@
+- Move over to standard and clear JSON format:
+
+All files should be of the form:
+
+{
+ "test1name":
+ {
+ "test1property1": ...,
+ "test1property2": ...,
+ ...
+ },
+ "test2name":
+ {
+ "test2property1": ...,
+ "test2property2": ...,
+ ...
+ }
+}
+
+Arrays are allowed, but don't use them for sets of properties - only use them for data that is clearly a continuous contiguous sequence of values.
+
diff --git a/tests/files/blockgenesistest.json b/tests/files/blockgenesistest.json
new file mode 100644
index 0000000000000000000000000000000000000000..8ad5590f11a42d619f80939643a50590cc42a04e
--- /dev/null
+++ b/tests/files/blockgenesistest.json
@@ -0,0 +1,20 @@
+[
+ {
+ "inputs": {
+ },
+ "result": "f892f88ea00000000000000000000000000000000000000000000000000000000000000000a01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d493479400000000000000000000000000000000000000008080834000008087038d7ea4c68000830f4240808080a004994f67dc55b09e814ab7ffc8df3686b4afb2bb53e60eae97ef043fe03fb829c0c0"
+ },
+ {
+ "inputs": {
+ "cd2a3d9f938e13cd947ec05abc7fe734df8dd826": 100000000000000000000
+ },
+ "result": "f8b2f8aea00000000000000000000000000000000000000000000000000000000000000000a01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347940000000000000000000000000000000000000000a05e5b074eca68ed6f5cf3ef14712b7c97f431a41deff21e3f211cf687f618026780834000008087038d7ea4c68000830f4240808080a004994f67dc55b09e814ab7ffc8df3686b4afb2bb53e60eae97ef043fe03fb829c0c0"
+ },
+ {
+ "inputs": {
+ "cd2a3d9f938e13cd947ec05abc7fe734df8dd826": 99000000000000000000,
+ "13978aee95f38490e9769c39b2773ed763d9cd5f": 1000000000000000000
+ },
+ "result": "f8b2f8aea00000000000000000000000000000000000000000000000000000000000000000a01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347940000000000000000000000000000000000000000a0b1062e564d1bdb302a2feae46e837fef59c4f8a408967009dcc48327d80d8fff80834000008087038d7ea4c68000830f4240808080a004994f67dc55b09e814ab7ffc8df3686b4afb2bb53e60eae97ef043fe03fb829c0c0"
+ }
+]
diff --git a/tests/files/genesishashestest.json b/tests/files/genesishashestest.json
new file mode 100644
index 0000000000000000000000000000000000000000..083d0700e2ee39726843fcd1b5696534911bb8fe
--- /dev/null
+++ b/tests/files/genesishashestest.json
@@ -0,0 +1,15 @@
+{
+ "genesis_rlp_hex": "f8abf8a7a00000000000000000000000000000000000000000000000000000000000000000a01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347940000000000000000000000000000000000000000a008bf6a98374f333b84e7d063d607696ac7cbbd409bd20fbe6a741c2dfc0eb28580830200008080830f4240808080a004994f67dc55b09e814ab7ffc8df3686b4afb2bb53e60eae97ef043fe03fb829c0c0",
+ "genesis_state_root": "08bf6a98374f333b84e7d063d607696ac7cbbd409bd20fbe6a741c2dfc0eb285",
+ "initial_alloc": {
+ "51ba59315b3a95761d0863b05ccc7a7f54703d99": "1606938044258990275541962092341162602522202993782792835301376",
+ "e4157b34ea9615cfbde6b4fda419828124b70c78": "1606938044258990275541962092341162602522202993782792835301376",
+ "b9c015918bdaba24b4ff057a92a3873d6eb201be": "1606938044258990275541962092341162602522202993782792835301376",
+ "6c386a4b26f73c802f34673f7248bb118f97424a": "1606938044258990275541962092341162602522202993782792835301376",
+ "cd2a3d9f938e13cd947ec05abc7fe734df8dd826": "1606938044258990275541962092341162602522202993782792835301376",
+ "2ef47100e0787b915105fd5e3f4ff6752079d5cb": "1606938044258990275541962092341162602522202993782792835301376",
+ "e6716f9544a56c530d868e4bfbacb172315bdead": "1606938044258990275541962092341162602522202993782792835301376",
+ "1a26338f0d905e295fccb71fa9ea849ffa12aaf4": "1606938044258990275541962092341162602522202993782792835301376"
+ },
+ "genesis_hash": "f68067286ddb7245c2203b18135456de1fc4ed6a24a2d9014195faa7900025bf"
+}
diff --git a/tests/files/hexencodetest.json b/tests/files/hexencodetest.json
new file mode 100644
index 0000000000000000000000000000000000000000..26c5bc7ed37fbc5b591b511366525be2e373b37b
--- /dev/null
+++ b/tests/files/hexencodetest.json
@@ -0,0 +1,62 @@
+{
+ "zz,odd,open": {
+ "seq": [ 0, 0, 1, 2, 3, 4, 5 ],
+ "term": false,
+ "out": "10012345"
+ },
+ "z,even,open": {
+ "seq": [ 0, 1, 2, 3, 4, 5 ],
+ "term": false,
+ "out": "00012345"
+ },
+ "nz,odd,open": {
+ "seq": [ 1, 2, 3, 4, 5 ],
+ "term": false,
+ "out": "112345"
+ },
+ "zz,even,open": {
+ "seq": [ 0, 0, 1, 2, 3, 4 ],
+ "term": false,
+ "out": "00001234"
+ },
+ "z,odd,open": {
+ "seq": [ 0, 1, 2, 3, 4 ],
+ "term": false,
+ "out": "101234"
+ },
+ "nz,even,open": {
+ "seq": [ 1, 2, 3, 4 ],
+ "term": false,
+ "out": "001234"
+ },
+ "zz,odd,term": {
+ "seq": [ 0, 0, 1, 2, 3, 4, 5 ],
+ "term": true,
+ "out": "30012345"
+ },
+ "z,even,term": {
+ "seq": [ 0, 1, 2, 3, 4, 5 ],
+ "term": true,
+ "out": "20012345"
+ },
+ "nz,odd,term": {
+ "seq": [ 1, 2, 3, 4, 5 ],
+ "term": true,
+ "out": "312345"
+ },
+ "zz,even,term": {
+ "seq": [ 0, 0, 1, 2, 3, 4 ],
+ "term": true,
+ "out": "20001234"
+ },
+ "z,odd,term": {
+ "seq": [ 0, 1, 2, 3, 4 ],
+ "term": true,
+ "out": "301234"
+ },
+ "nz,even,term": {
+ "seq": [ 1, 2, 3, 4 ],
+ "term": true,
+ "out": "201234"
+ }
+}
diff --git a/tests/files/index.js b/tests/files/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..84615a4827dc10c4dfceed0ed4b55d3f36b6308c
--- /dev/null
+++ b/tests/files/index.js
@@ -0,0 +1,23 @@
+module.exports = {
+ blockgenesis: require('./blockgenesistest'),
+ genesishashes: require('./genesishashestest'),
+ hexencode: require('./hexencodetest'),
+ keyaddrtests: require('./keyaddrtest'),
+ namecoin: require('./namecoin'),
+ rlptest: require('./rlptest'),
+ trietest: require('./trietest'),
+ trietestnextprev: require('./trietestnextprev'),
+ txtest: require('./txtest'),
+ vmtests: {
+ random: require('./vmtests/random'),
+ vmArithmeticTest: require('./vmtests/vmArithmeticTest'),
+ vmBitwiseLogicOperationTest: require('./vmtests/vmBitwiseLogicOperationTest'),
+ vmBlockInfoTest: require('./vmtests/vmBlockInfoTest'),
+ vmEnvironmentalInfoTest: require('./vmtests/vmEnvironmentalInfoTest'),
+ vmIOandFlowOperationsTest: require('./vmtests/vmIOandFlowOperationsTest'),
+ vmPushDupSwapTest: require('./vmtests/vmPushDupSwapTest'),
+ vmSha3Test: require('./vmtests/vmSha3Test'),
+ vmSystemOperationsTest: require('./vmtests/vmSystemOperationsTest'),
+ vmtests: require('./vmtests/vmtests')
+ }
+};
diff --git a/tests/files/keyaddrtest.json b/tests/files/keyaddrtest.json
new file mode 100644
index 0000000000000000000000000000000000000000..c65b2ae33bd24cca7d2dc60c57b3d03bbe01d989
--- /dev/null
+++ b/tests/files/keyaddrtest.json
@@ -0,0 +1,22 @@
+[
+ {
+ "seed": "cow",
+ "key": "c85ef7d79691fe79573b1a7064c19c1a9819ebdbd1faaab1a8ec92344438aaf4",
+ "addr": "cd2a3d9f938e13cd947ec05abc7fe734df8dd826",
+ "sig_of_emptystring": {
+ "v": "27",
+ "r": "55022946425863772466282515086640833500580355555249003729267710149987842051473",
+ "s": "3021698389129950584349170550428805649435913935175976180112863059249983907949"
+ }
+ },
+ {
+ "seed": "horse",
+ "key": "c87f65ff3f271bf5dc8643484f66b200109caffe4bf98c4cb393dc35740b28c0",
+ "addr": "13978aee95f38490e9769c39b2773ed763d9cd5f",
+ "sig_of_emptystring": {
+ "v": "28",
+ "r": "20570452350081260599473412372903969148670549754219103025003129053348571714359",
+ "s": "76892551129780267788164835941580941601518827936179476514262023835864819088004"
+ }
+ }
+]
diff --git a/tests/files/namecoin.json b/tests/files/namecoin.json
new file mode 100644
index 0000000000000000000000000000000000000000..64c2c550aad325dc89c1b8d860f8458f7486b52e
--- /dev/null
+++ b/tests/files/namecoin.json
@@ -0,0 +1,55 @@
+{
+ "namecoin": {
+ "pre": {
+ "82a978b3f5962a5b0957d9ee9eef472ee55b42f1": {
+ "nonce": "1",
+ "balance": "2500000000000000000",
+ "storage": {},
+ "code": "0x"
+ },
+ "c305c901078781c232a2a521c2af7980f8385ee9": {
+ "nonce": "0",
+ "balance": "0",
+ "storage": {},
+ "code": "0x600035560f0f601d5960203560003557600160005460206000f2602758600060205460206020f2"
+ }
+ },
+ "exec": {
+ "origin": "82a978b3f5962a5b0957d9ee9eef472ee55b42f1",
+ "code": "0x600035560f0f601d5960203560003557600160005460206000f2602758600060205460206020f2",
+ "value": "0",
+ "address": "c305c901078781c232a2a521c2af7980f8385ee9",
+ "gas": "10000",
+ "caller": "82a978b3f5962a5b0957d9ee9eef472ee55b42f1",
+ "data": "0x000000000000000000000000000000000000000000000000000000000000002d000000000000000000000000000000000000000000000000000000000000004e",
+ "gasPrice": "1000000000000"
+ },
+ "callcreates": [],
+ "gas": "9763",
+ "env": {
+ "currentTimestamp": "1405282164",
+ "currentGasLimit": "999023",
+ "previousHash": "112a6e7995fcb66376f44e52f011c38d328a9ed3a1dac6eebb1376fccd055fad",
+ "currentCoinbase": "82a978b3f5962a5b0957d9ee9eef472ee55b42f1",
+ "currentDifficulty": "4190208",
+ "currentNumber": "1"
+ },
+ "post": {
+ "82a978b3f5962a5b0957d9ee9eef472ee55b42f1": {
+ "nonce": "1",
+ "balance": "2500000000000000000",
+ "storage": {},
+ "code": "0x"
+ },
+ "c305c901078781c232a2a521c2af7980f8385ee9": {
+ "nonce": "0",
+ "balance": "0",
+ "storage": {
+ "0x2d": "0x4e"
+ },
+ "code": "0x600035560f0f601d5960203560003557600160005460206000f2602758600060205460206020f2"
+ }
+ },
+ "out": "0x0000000000000000000000000000000000000000000000000000000000000001"
+ }
+}
diff --git a/tests/files/package.json b/tests/files/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..eb0841450e1a8b43741ebe9eac687ba55c724e9e
--- /dev/null
+++ b/tests/files/package.json
@@ -0,0 +1,23 @@
+{
+ "name": "ethereum-tests",
+ "version": "0.0.0",
+ "description": "tests for ethereum",
+ "main": "index.js",
+ "scripts": {
+ "test": "echo \"There are no tests for there tests\" && exit 1"
+ },
+ "repository": {
+ "type": "git",
+ "url": "https://github.com/ethereum/tests"
+ },
+ "keywords": [
+ "tests",
+ "ethereum"
+ ],
+ "author": "",
+ "license": "MIT",
+ "bugs": {
+ "url": "https://github.com/ethereum/tests/issues"
+ },
+ "homepage": "https://github.com/ethereum/tests"
+}
diff --git a/tests/files/randomTests/201410211705.json b/tests/files/randomTests/201410211705.json
new file mode 100644
index 0000000000000000000000000000000000000000..758483afca7695cc6ea42d3186b327a51ce4936d
--- /dev/null
+++ b/tests/files/randomTests/201410211705.json
@@ -0,0 +1,45 @@
+{
+ "randomVMtest" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x33410c45815741f394",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9794",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x33410c45815741f394",
+ "nonce" : "0",
+ "storage" : {
+ "0x01" : "0x0f4240"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x33410c45815741f394",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ }
+}
diff --git a/tests/files/randomTests/201410211708.json b/tests/files/randomTests/201410211708.json
new file mode 100644
index 0000000000000000000000000000000000000000..492be2391a897749592034886918e4919403ed1f
--- /dev/null
+++ b/tests/files/randomTests/201410211708.json
@@ -0,0 +1,44 @@
+{
+ "randomVMtest" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7d",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9999",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7d",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7d",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ }
+}
diff --git a/tests/files/rlptest.json b/tests/files/rlptest.json
new file mode 100644
index 0000000000000000000000000000000000000000..19adbb8e22f3719e8a74f0e9eccb3d0d868ece56
--- /dev/null
+++ b/tests/files/rlptest.json
@@ -0,0 +1,146 @@
+{
+ "emptystring": {
+ "in": "",
+ "out": "80"
+ },
+ "shortstring": {
+ "in": "dog",
+ "out": "83646f67"
+ },
+ "shortstring2": {
+ "in": "Lorem ipsum dolor sit amet, consectetur adipisicing eli",
+ "out": "b74c6f72656d20697073756d20646f6c6f722073697420616d65742c20636f6e7365637465747572206164697069736963696e6720656c69"
+ },
+ "longstring": {
+ "in": "Lorem ipsum dolor sit amet, consectetur adipisicing elit",
+ "out": "b8384c6f72656d20697073756d20646f6c6f722073697420616d65742c20636f6e7365637465747572206164697069736963696e6720656c6974"
+ },
+ "longstring2": {
+ "in": "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Curabitur mauris magna, suscipit sed vehicula non, iaculis faucibus tortor. Proin suscipit ultricies malesuada. Duis tortor elit, dictum quis tristique eu, ultrices at risus. Morbi a est imperdiet mi ullamcorper aliquet suscipit nec lorem. Aenean quis leo mollis, vulputate elit varius, consequat enim. Nulla ultrices turpis justo, et posuere urna consectetur nec. Proin non convallis metus. Donec tempor ipsum in mauris congue sollicitudin. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae; Suspendisse convallis sem vel massa faucibus, eget lacinia lacus tempor. Nulla quis ultricies purus. Proin auctor rhoncus nibh condimentum mollis. Aliquam consequat enim at metus luctus, a eleifend purus egestas. Curabitur at nibh metus. Nam bibendum, neque at auctor tristique, lorem libero aliquet arcu, non interdum tellus lectus sit amet eros. Cras rhoncus, metus ac ornare cursus, dolor justo ultrices metus, at ullamcorper volutpat",
+ "out": "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"
+ },
+ "zero": {
+ "in": 0,
+ "out": "80"
+ },
+ "smallint": {
+ "in": 1,
+ "out": "01"
+ },
+ "smallint2": {
+ "in": 16,
+ "out": "10"
+ },
+ "smallint3": {
+ "in": 79,
+ "out": "4f"
+ },
+ "smallint4": {
+ "in": 127,
+ "out": "7f"
+ },
+ "mediumint1": {
+ "in": 128,
+ "out": "8180"
+ },
+ "mediumint2": {
+ "in": 1000,
+ "out": "8203e8"
+ },
+ "mediumint3": {
+ "in": 100000,
+ "out": "830186a0"
+ },
+ "mediumint4": {
+ "in": "#83729609699884896815286331701780722",
+ "out": "8F102030405060708090A0B0C0D0E0F2"
+ },
+ "mediumint5": {
+ "in": "#105315505618206987246253880190783558935785933862974822347068935681",
+ "out": "9C0100020003000400050006000700080009000A000B000C000D000E01"
+ },
+ "emptylist": {
+ "in": [],
+ "out": "c0"
+ },
+ "stringlist": {
+ "in": [ "dog", "god", "cat" ],
+ "out": "cc83646f6783676f6483636174"
+ },
+ "multilist": {
+ "in": [ "zw", [ 4 ], 1 ],
+ "out": "c6827a77c10401"
+ },
+ "shortListMax1": {
+ "in": [ "asdf", "qwer", "zxcv", "asdf","qwer", "zxcv", "asdf", "qwer", "zxcv", "asdf", "qwer"],
+ "out": "F784617364668471776572847a78637684617364668471776572847a78637684617364668471776572847a78637684617364668471776572"
+ },
+ "longList1" : {
+ "in" : [
+ ["asdf","qwer","zxcv"],
+ ["asdf","qwer","zxcv"],
+ ["asdf","qwer","zxcv"],
+ ["asdf","qwer","zxcv"]
+ ],
+ "out": "F840CF84617364668471776572847a786376CF84617364668471776572847a786376CF84617364668471776572847a786376CF84617364668471776572847a786376"
+ },
+ "longList2" : {
+ "in" : [
+ ["asdf","qwer","zxcv"],
+ ["asdf","qwer","zxcv"],
+ ["asdf","qwer","zxcv"],
+ ["asdf","qwer","zxcv"],
+ ["asdf","qwer","zxcv"],
+ ["asdf","qwer","zxcv"],
+ ["asdf","qwer","zxcv"],
+ ["asdf","qwer","zxcv"],
+ ["asdf","qwer","zxcv"],
+ ["asdf","qwer","zxcv"],
+ ["asdf","qwer","zxcv"],
+ ["asdf","qwer","zxcv"],
+ ["asdf","qwer","zxcv"],
+ ["asdf","qwer","zxcv"],
+ ["asdf","qwer","zxcv"],
+ ["asdf","qwer","zxcv"],
+ ["asdf","qwer","zxcv"],
+ ["asdf","qwer","zxcv"],
+ ["asdf","qwer","zxcv"],
+ ["asdf","qwer","zxcv"],
+ ["asdf","qwer","zxcv"],
+ ["asdf","qwer","zxcv"],
+ ["asdf","qwer","zxcv"],
+ ["asdf","qwer","zxcv"],
+ ["asdf","qwer","zxcv"],
+ ["asdf","qwer","zxcv"],
+ ["asdf","qwer","zxcv"],
+ ["asdf","qwer","zxcv"],
+ ["asdf","qwer","zxcv"],
+ ["asdf","qwer","zxcv"],
+ ["asdf","qwer","zxcv"],
+ ["asdf","qwer","zxcv"]
+ ],
+ "out": "F90200CF84617364668471776572847a786376CF84617364668471776572847a786376CF84617364668471776572847a786376CF84617364668471776572847a786376CF84617364668471776572847a786376CF84617364668471776572847a786376CF84617364668471776572847a786376CF84617364668471776572847a786376CF84617364668471776572847a786376CF84617364668471776572847a786376CF84617364668471776572847a786376CF84617364668471776572847a786376CF84617364668471776572847a786376CF84617364668471776572847a786376CF84617364668471776572847a786376CF84617364668471776572847a786376CF84617364668471776572847a786376CF84617364668471776572847a786376CF84617364668471776572847a786376CF84617364668471776572847a786376CF84617364668471776572847a786376CF84617364668471776572847a786376CF84617364668471776572847a786376CF84617364668471776572847a786376CF84617364668471776572847a786376CF84617364668471776572847a786376CF84617364668471776572847a786376CF84617364668471776572847a786376CF84617364668471776572847a786376CF84617364668471776572847a786376CF84617364668471776572847a786376CF84617364668471776572847a786376"
+ },
+
+ "listsoflists": {
+ "in": [ [ [], [] ], [] ],
+ "out": "c4c2c0c0c0"
+ },
+ "listsoflists2": {
+ "in": [ [], [[]], [ [], [[]] ] ],
+ "out": "c7c0c1c0c3c0c1c0"
+ },
+ "dictTest1" : {
+ "in" : [
+ ["key1", "val1"],
+ ["key2", "val2"],
+ ["key3", "val3"],
+ ["key4", "val4"]
+ ],
+ "out" : "ECCA846b6579318476616c31CA846b6579328476616c32CA846b6579338476616c33CA846b6579348476616c34"
+ },
+ "bigint": {
+ "in": "#115792089237316195423570985008687907853269984665640564039457584007913129639936",
+ "out": "a1010000000000000000000000000000000000000000000000000000000000000000"
+ }
+}
diff --git a/tests/files/trietest.json b/tests/files/trietest.json
new file mode 100644
index 0000000000000000000000000000000000000000..317429649a1f09e40b36860ce21fa4ab16aaefa6
--- /dev/null
+++ b/tests/files/trietest.json
@@ -0,0 +1,84 @@
+{
+ "singleItem": {
+ "in": {
+ "A": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+ },
+ "root": "d23786fb4a010da3ce639d66d5e904a11dbc02746d1ce25029e53290cabf28ab"
+ },
+ "dogs": {
+ "in": {
+ "doe": "reindeer",
+ "dog": "puppy",
+ "dogglesworth": "cat"
+ },
+ "root": "8aad789dff2f538bca5d8ea56e8abe10f4c7ba3a5dea95fea4cd6e7c3a1168d3"
+ },
+ "puppy": {
+ "in": {
+ "do": "verb",
+ "horse": "stallion",
+ "doge": "coin",
+ "dog": "puppy"
+ },
+ "root": "5991bb8c6514148a29db676a14ac506cd2cd5775ace63c30a4fe457715e9ac84"
+ },
+ "emptyValues": {
+ "in": {
+ "do": "verb",
+ "ether": "wookiedoo",
+ "horse": "stallion",
+ "shaman": "horse",
+ "doge": "coin",
+ "ether": "",
+ "dog": "puppy",
+ "shaman": ""
+ },
+ "root": "4505cb6d817068bcd68fb225ab4d5ab70860461d3b35738bf6bcf7b44d702d0d"
+ },
+ "foo": {
+ "in": {
+ "foo": "bar",
+ "food": "bat",
+ "food": "bass"
+ },
+ "root": "17beaa1648bafa633cda809c90c04af50fc8aed3cb40d16efbddee6fdf63c4c3"
+ },
+ "smallValues": {
+ "in": {
+ "be": "e",
+ "dog": "puppy",
+ "bed": "d"
+ },
+ "root": "3f67c7a47520f79faa29255d2d3c084a7a6df0453116ed7232ff10277a8be68b"
+ },
+ "testy": {
+ "in": {
+ "test": "test",
+ "te": "testy"
+ },
+ "root": "8452568af70d8d140f58d941338542f645fcca50094b20f3c3d8c3df49337928"
+ },
+ "hex": {
+ "in": {
+ "0x0045": "0x0123456789",
+ "0x4500": "0x9876543210"
+ },
+ "root": "285505fcabe84badc8aa310e2aae17eddc7d120aabec8a476902c8184b3a3503"
+ },
+ "jeff": {
+ "in": {
+ "0x0000000000000000000000000000000000000000000000000000000000000045": "0x22b224a1420a802ab51d326e29fa98e34c4f24ea",
+ "0x0000000000000000000000000000000000000000000000000000000000000046": "0x67706c2076330000000000000000000000000000000000000000000000000000",
+ "0x0000000000000000000000000000000000000000000000000000001234567890": "0x697c7b8c961b56f675d570498424ac8de1a918f6",
+ "0x000000000000000000000000697c7b8c961b56f675d570498424ac8de1a918f6": "0x1234567890",
+ "0x0000000000000000000000007ef9e639e2733cb34e4dfc576d4b23f72db776b2": "0x4655474156000000000000000000000000000000000000000000000000000000",
+ "0x000000000000000000000000ec4f34c97e43fbb2816cfd95e388353c7181dab1": "0x4e616d6552656700000000000000000000000000000000000000000000000000",
+ "0x4655474156000000000000000000000000000000000000000000000000000000": "0x7ef9e639e2733cb34e4dfc576d4b23f72db776b2",
+ "0x4e616d6552656700000000000000000000000000000000000000000000000000": "0xec4f34c97e43fbb2816cfd95e388353c7181dab1",
+ "0x0000000000000000000000000000000000000000000000000000001234567890": "",
+ "0x000000000000000000000000697c7b8c961b56f675d570498424ac8de1a918f6": "0x6f6f6f6820736f2067726561742c207265616c6c6c793f000000000000000000",
+ "0x6f6f6f6820736f2067726561742c207265616c6c6c793f000000000000000000": "0x697c7b8c961b56f675d570498424ac8de1a918f6"
+ },
+ "root": "088c8e162c91c75ca9efa63f21530bbc6964cff7453a5d6af8404d090292a3e7"
+ }
+}
diff --git a/tests/files/trietestnextprev.json b/tests/files/trietestnextprev.json
new file mode 100644
index 0000000000000000000000000000000000000000..f2ad924e30acf534794599e95115b20049acffd8
--- /dev/null
+++ b/tests/files/trietestnextprev.json
@@ -0,0 +1,19 @@
+{
+ "basic": {
+ "in": [ "cat", "doge", "wallace" ],
+ "tests": [
+ [ "", "", "cat" ],
+ [ "bobo", "", "cat" ],
+ [ "c", "", "cat" ],
+ [ "car", "", "cat" ],
+ [ "cat", "", "doge" ],
+ [ "catering", "cat", "doge" ],
+ [ "d", "cat", "doge" ],
+ [ "doge", "cat", "wallace" ],
+ [ "dogerton", "doge", "wallace" ],
+ [ "w", "doge", "wallace" ],
+ [ "wallace", "doge", "" ],
+ [ "wallace123", "wallace", ""]
+ ]
+ }
+}
diff --git a/tests/files/txtest.json b/tests/files/txtest.json
new file mode 100644
index 0000000000000000000000000000000000000000..1261d07660203830c7766ca9573605fcff331728
--- /dev/null
+++ b/tests/files/txtest.json
@@ -0,0 +1,24 @@
+[
+ {
+ "key": "c85ef7d79691fe79573b1a7064c19c1a9819ebdbd1faaab1a8ec92344438aaf4",
+ "nonce": 0,
+ "gasprice": 1000000000000,
+ "startgas": 10000,
+ "to": "13978aee95f38490e9769c39b2773ed763d9cd5f",
+ "value": 10000000000000000,
+ "data": "",
+ "unsigned": "eb8085e8d4a510008227109413978aee95f38490e9769c39b2773ed763d9cd5f872386f26fc1000080808080",
+ "signed": "f86b8085e8d4a510008227109413978aee95f38490e9769c39b2773ed763d9cd5f872386f26fc10000801ba0eab47c1a49bf2fe5d40e01d313900e19ca485867d462fe06e139e3a536c6d4f4a014a569d327dcda4b29f74f93c0e9729d2f49ad726e703f9cd90dbb0fbf6649f1"
+ },
+ {
+ "key": "c87f65ff3f271bf5dc8643484f66b200109caffe4bf98c4cb393dc35740b28c0",
+ "nonce": 0,
+ "gasprice": 1000000000000,
+ "startgas": 10000,
+ "to": "",
+ "value": 0,
+ "data": "6025515b525b600a37f260003556601b596020356000355760015b525b54602052f260255860005b525b54602052f2",
+ "unsigned": "f83f8085e8d4a510008227108080af6025515b525b600a37f260003556601b596020356000355760015b525b54602052f260255860005b525b54602052f2808080",
+ "signed": "f87f8085e8d4a510008227108080af6025515b525b600a37f260003556601b596020356000355760015b525b54602052f260255860005b525b54602052f21ba05afed0244d0da90b67cf8979b0f246432a5112c0d31e8d5eedd2bc17b171c694a0bb1035c834677c2e1185b8dc90ca6d1fa585ab3d7ef23707e1a497a98e752d1b"
+ }
+]
diff --git a/tests/files/vmtests/random.json b/tests/files/vmtests/random.json
new file mode 100644
index 0000000000000000000000000000000000000000..76248c85e2e3d017b42cf4b56d02bafde0347ddf
--- /dev/null
+++ b/tests/files/vmtests/random.json
@@ -0,0 +1,59 @@
+{
+ "random": {
+ "pre": {
+ "7d577a597b2742b498cb5cf0c26cdcd726d39e6e": {
+ "nonce": "0",
+ "balance": "1",
+ "storage": {},
+ "code": "0x"
+ },
+ "82a978b3f5962a5b0957d9ee9eef472ee55b42f1": {
+ "nonce": "0",
+ "balance": "2500000000000000000",
+ "storage": {},
+ "code": "0x"
+ }
+ },
+ "exec": {
+ "origin": "82a978b3f5962a5b0957d9ee9eef472ee55b42f1",
+ "code": "0x60f86363f011b260c16324413d44608e633688a34a6043637657ab003809060b0cff0aff00070f413041f234344542020f0043393104590c09325c13383458f137f0600845f205300a0d36030b35402011393635395454593a015940",
+ "value": "0",
+ "address": "7d577a597b2742b498cb5cf0c26cdcd726d39e6e",
+ "gas": "10000",
+ "caller": "82a978b3f5962a5b0957d9ee9eef472ee55b42f1",
+ "data": "0x604e63f12f6b0c60426319bcb28060986330a233e8604463265e809d0104600a3af0f10ff10d0c1336114408583a33f05135410160540f524057201313440d585513f25c54115c433a0d37045a5212094109f10108125c35100f535a",
+ "gasPrice": "1000000000000"
+ },
+ "callcreates": [],
+ "gas": "9987",
+ "env": {
+ "currentTimestamp": "1405320512",
+ "currentGasLimit": "999023",
+ "previousHash": "112a6e7995fcb66376f44e52f011c38d328a9ed3a1dac6eebb1376fccd055fad",
+ "currentCoinbase": "82a978b3f5962a5b0957d9ee9eef472ee55b42f1",
+ "currentDifficulty": "4190208",
+ "currentNumber": "1"
+ },
+ "post": {
+ "0000000000000000000000000000000000000001": {
+ "nonce": "0",
+ "balance": "1",
+ "storage": {},
+ "code": "0x"
+ },
+ "7d577a597b2742b498cb5cf0c26cdcd726d39e6e": {
+ "nonce": "0",
+ "balance": "0",
+ "storage": {},
+ "code": "0x"
+ },
+ "82a978b3f5962a5b0957d9ee9eef472ee55b42f1": {
+ "nonce": "0",
+ "balance": "2500000000000000000",
+ "storage": {},
+ "code": "0x"
+ }
+ },
+ "out": "0x"
+ }
+}
diff --git a/tests/files/vmtests/vmArithmeticTest.json b/tests/files/vmtests/vmArithmeticTest.json
new file mode 100644
index 0000000000000000000000000000000000000000..5df9965b761cba45c2756ccaf57d4cc56dc943f0
--- /dev/null
+++ b/tests/files/vmtests/vmArithmeticTest.json
@@ -0,0 +1,3239 @@
+{
+ "add0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff01600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff01600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff01600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "add1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x60047fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff01600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60047fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff01600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x03"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60047fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff01600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "add2" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "10000",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "add3" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6000600001600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9896",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6000600001600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6000600001600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "add4" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff600101600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9896",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff600101600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff600101600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "divByNonZero0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6002600504600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6002600504600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x02"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6002600504600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "divByNonZero1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6018601704600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9896",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6018601704600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6018601704600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "divByNonZero2" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6018600004600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9896",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6018600004600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6018600004600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "divByNonZero3" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6001600104600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6001600104600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6001600104600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "divByZero" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6000600204600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9896",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6000600204600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6000600204600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "eq0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600360000360056000030e600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9892",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600360000360056000030e600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600360000360056000030e600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "eq1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600060000e600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600060000e600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600060000e600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "eq2" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0e600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0e600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0e600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "exp0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6002600208600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6002600208600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x04"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6002600208600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "exp1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff08600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff08600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff08600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "exp2" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x637fffffff637fffffff08600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x637fffffff637fffffff08600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0xbc8cccccccc888888880000000aaaaaab00000000fffffffffffffff7fffffff"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x637fffffff637fffffff08600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "exp3" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x637fffffff600008600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9896",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x637fffffff600008600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x637fffffff600008600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "exp4" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6000637fffffff08600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6000637fffffff08600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6000637fffffff08600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "exp5" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600161010108600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600161010108600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x0101"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600161010108600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "exp6" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x610101600108600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x610101600108600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x610101600108600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "exp7" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x610101600208600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9896",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x610101600208600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x610101600208600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "gt0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600060026000030b600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9794",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600060026000030b600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600060026000030b600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "gt1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600260000360000b600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9894",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600260000360000b600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600260000360000b600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "gt2" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0b600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0b600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0b600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "gt3" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60000b600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9896",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60000b600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60000b600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "lt0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600060026000030a600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9894",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600060026000030a600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600060026000030a600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "lt1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600260000360000a600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9794",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600260000360000a600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600260000360000a600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "lt2" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0a600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9896",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0a600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0a600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "lt3" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60000a600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60000a600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60000a600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "mod0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6003600206600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6003600206600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x02"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6003600206600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "mod1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x60027fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff06600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60027fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff06600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60027fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff06600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "mod2" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff600006600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9896",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff600006600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff600006600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "mod3" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6000600306600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9896",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6000600306600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6000600306600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "mod4" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6003600260000306600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9794",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6003600260000306600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x02"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6003600260000306600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "mul0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6003600202600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6003600202600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x06"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6003600202600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "mul1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff02600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff02600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff02600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "mul2" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6017600002600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9896",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6017600002600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6017600002600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "mul3" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6001601702600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6001601702600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x17"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6001601702600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "mul4" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f800000000000000000000000000000000000000000000000000000000000000002600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f800000000000000000000000000000000000000000000000000000000000000002600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x8000000000000000000000000000000000000000000000000000000000000000"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f800000000000000000000000000000000000000000000000000000000000000002600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "mul5" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7f80000000000000000000000000000000000000000000000000000000000000007f800000000000000000000000000000000000000000000000000000000000000002600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9896",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7f80000000000000000000000000000000000000000000000000000000000000007f800000000000000000000000000000000000000000000000000000000000000002600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7f80000000000000000000000000000000000000000000000000000000000000007f800000000000000000000000000000000000000000000000000000000000000002600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "mul6" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7f7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff02600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7f7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff02600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7f7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff02600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "neg0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600009600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9897",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600009600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600009600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "neg1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600209600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9797",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600209600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600209600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "neg2" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff09600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9797",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff09600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff09600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "neg3" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600260000309600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9795",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600260000309600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x02"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600260000309600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "neg4" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60000309600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9795",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60000309600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60000309600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "neg5" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600060000309600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9895",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600060000309600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600060000309600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "not0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0f600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9897",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0f600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0f600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "not1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x60000f600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9797",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60000f600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60000f600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "sdiv0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60000305600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9794",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60000305600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60000305600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "sdiv1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff6000037fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff05600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9794",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff6000037fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff05600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff6000037fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff05600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "sdiv2" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6004600003600260000305600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9892",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6004600003600260000305600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6004600003600260000305600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "sdiv3" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6002600003600405600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9794",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6002600003600405600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6002600003600405600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "sdivByZero0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6000600003600360000305600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9892",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6000600003600360000305600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6000600003600360000305600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "sdivByZero1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60000305600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9894",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60000305600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60000305600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "sgt0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600060026000030d600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9894",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600060026000030d600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600060026000030d600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "sgt1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600260000360000d600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9794",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600260000360000d600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600260000360000d600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "sgt2" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0d600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9896",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0d600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0d600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "sgt3" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60000d600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60000d600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60000d600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "sgt4" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600360000360056000030d600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9892",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600360000360056000030d600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600360000360056000030d600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "slt0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600060026000030c600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9794",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600060026000030c600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600060026000030c600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "slt1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600260000360000c600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9894",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600260000360000c600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600260000360000c600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "slt2" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0c600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0c600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0c600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "slt3" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60000c600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9896",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60000c600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff60000c600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "slt4" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600360000360056000030c600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9792",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600360000360056000030c600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600360000360056000030c600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "smod0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6003600003600560000307600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9792",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6003600003600560000307600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6003600003600560000307600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "smod1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6003600003600507600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9794",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6003600003600507600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x02"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6003600003600507600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "smod2" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6003600560000307600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9794",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6003600560000307600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6003600560000307600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "smod3" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff600260000307600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9894",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff600260000307600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff600260000307600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "smod4" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6000600260000307600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9894",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6000600260000307600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6000600260000307600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "stop" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x00",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "10000",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x00",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x00",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "sub0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6001601703600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6001601703600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x16"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6001601703600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "sub1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6003600203600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6003600203600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6003600203600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "sub2" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6017600003600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6017600003600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe9"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6017600003600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "sub3" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff600003600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff600003600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff600003600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "sub4" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff03600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff03600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff03600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/tests/files/vmtests/vmBitwiseLogicOperationTest.json b/tests/files/vmtests/vmBitwiseLogicOperationTest.json
new file mode 100644
index 0000000000000000000000000000000000000000..840c40a943c9fce94094b912daccd8a9348902d8
--- /dev/null
+++ b/tests/files/vmtests/vmBitwiseLogicOperationTest.json
@@ -0,0 +1,1882 @@
+{
+ "addmod0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x60026002600114600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9795",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60026002600114600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60026002600114600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "addmod1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x60026002600003600160000314600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9791",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60026002600003600160000314600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60026002600003600160000314600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "addmod2" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x60036001600660000314600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9793",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60036001600660000314600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x02"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60036001600660000314600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "addmod2_0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6003600160066000031460036005600003070e600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9887",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6003600160066000031460036005600003070e600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6003600160066000031460036005600003070e600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "addmod2_1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6003600160066000031460036005600003060e600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9787",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6003600160066000031460036005600003060e600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6003600160066000031460036005600003060e600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "addmod3" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x60036000036001600414600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9793",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60036000036001600414600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x05"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60036000036001600414600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "addmod3_0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6002600360000360016004140e600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9891",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6002600360000360016004140e600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6002600360000360016004140e600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "and0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6002600210600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6002600210600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x02"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6002600210600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "and1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6001600210600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9896",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6001600210600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6001600210600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "and2" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6001600310600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6001600310600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6001600310600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "and3" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7f0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff10600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7f0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff10600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7f0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff10600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "and4" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7feeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee10600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7feeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee10600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7feeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee10600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "and5" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7feeeeeeeeeeeeeeeeeeeeeeeeeeeeefeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee10600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7feeeeeeeeeeeeeeeeeeeeeeeeeeeeefeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee10600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeefeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7feeeeeeeeeeeeeeeeeeeeeeeeeeeeefeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee10600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "byte0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6780402010080402016000601f0313600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9794",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6780402010080402016000601f0313600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6780402010080402016000601f0313600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "byte1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6780402010080402016001601f0313600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9794",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6780402010080402016001601f0313600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x02"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6780402010080402016001601f0313600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "byte10" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6780402010080402017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff13600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9896",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6780402010080402017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff13600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6780402010080402017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff13600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "byte11" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x678040201008040201600013600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9896",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x678040201008040201600013600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x678040201008040201600013600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "byte2" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6780402010080402016002601f0313600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9794",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6780402010080402016002601f0313600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x04"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6780402010080402016002601f0313600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "byte3" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6780402010080402016003601f0313600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9794",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6780402010080402016003601f0313600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x08"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6780402010080402016003601f0313600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "byte4" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6780402010080402016004601f0313600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9794",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6780402010080402016004601f0313600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x10"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6780402010080402016004601f0313600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "byte5" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6780402010080402016005601f0313600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9794",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6780402010080402016005601f0313600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x20"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6780402010080402016005601f0313600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "byte6" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6780402010080402016006601f0313600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9794",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6780402010080402016006601f0313600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x40"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6780402010080402016006601f0313600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "byte7" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6780402010080402016007601f0313600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9794",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6780402010080402016007601f0313600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x80"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6780402010080402016007601f0313600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "byte8" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x678040201008040201601f601f0313600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9894",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x678040201008040201601f601f0313600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x678040201008040201601f601f0313600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "byte9" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6780402010080402016020601f0513600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9894",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6780402010080402016020601f0513600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6780402010080402016020601f0513600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "mulmod0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x60026002600115600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9895",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60026002600115600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60026002600115600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "mulmod1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x60036002600003600160000315600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9891",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60036002600003600160000315600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60036002600003600160000315600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "mulmod2" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x60036001600560000315600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9793",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60036001600560000315600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x02"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60036001600560000315600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "mulmod2_0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6003600160056000031560036005600003070e600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9887",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6003600160056000031560036005600003070e600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6003600160056000031560036005600003070e600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "mulmod2_1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6003600160056000031560036005600003060e600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9787",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6003600160056000031560036005600003060e600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6003600160056000031560036005600003060e600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "mulmod3" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x60036000036001600515600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9793",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60036000036001600515600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x05"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60036000036001600515600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "mulmod3_0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6002600360000360016005150e600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9891",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6002600360000360016005150e600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6002600360000360016005150e600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "or0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6002600211600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6002600211600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x02"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6002600211600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "or1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6001600211600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6001600211600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x03"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6001600211600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "or2" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6001600311600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6001600311600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x03"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6001600311600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "or3" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7f0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff11600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7f0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff11600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7f0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff11600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "or4" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7feeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee11600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7feeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee11600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7feeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee11600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "or5" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7feeeeeeeeeeeeeeeeeeeeeeeeeeeeefeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee11600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7feeeeeeeeeeeeeeeeeeeeeeeeeeeeefeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee11600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7feeeeeeeeeeeeeeeeeeeeeeeeeeeeefeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee11600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "xor0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6002600212600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9896",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6002600212600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6002600212600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "xor1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6001600212600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6001600212600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x03"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6001600212600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "xor2" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6001600312600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6001600312600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x02"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6001600312600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "xor3" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7f0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff12600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7f0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff12600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0xfedcba9876543210fedcba9876543210fedcba9876543210fedcba9876543210"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7f0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff12600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "xor4" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7feeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee12600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7feeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee12600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x1111111111111111111111111111111111111111111111111111111111111111"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7feeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee12600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "xor5" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7feeeeeeeeeeeeeeeeeeeeeeeeeeeeefeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee12600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7feeeeeeeeeeeeeeeeeeeeeeeeeeeeefeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee12600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x1111111111111111111111111111101111111111111111111111111111111111"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7feeeeeeeeeeeeeeeeeeeeeeeeeeeeefeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee12600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/tests/files/vmtests/vmBlockInfoTest.json b/tests/files/vmtests/vmBlockInfoTest.json
new file mode 100644
index 0000000000000000000000000000000000000000..f22060dd310e90eeb1ee4b629c248e2c178dc3b9
--- /dev/null
+++ b/tests/files/vmtests/vmBlockInfoTest.json
@@ -0,0 +1,259 @@
+{
+ "coinbase" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x41600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9798",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x41600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x41600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "difficulty" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x44600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9798",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x44600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x0100"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x44600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "gaslimit" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x45600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9798",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x45600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x0f4240"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x45600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "number" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x43600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9898",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x43600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x43600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "prevhash" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x40600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9798",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x40600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x40600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "timestamp" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x42600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9798",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x42600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x42600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/tests/files/vmtests/vmEnvironmentalInfoTest.json b/tests/files/vmtests/vmEnvironmentalInfoTest.json
new file mode 100644
index 0000000000000000000000000000000000000000..35ad5f8f10e60a7a0b3a9b5dad8c9c49c184a2f7
--- /dev/null
+++ b/tests/files/vmtests/vmEnvironmentalInfoTest.json
@@ -0,0 +1,1131 @@
+{
+ "address0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x30600057",
+ "data" : "0x",
+ "gas" : "100000000000",
+ "gasPrice" : "1000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "99999999798",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x30600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x30600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "address1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "caller" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "code" : "0x30600057",
+ "data" : "0x",
+ "gas" : "100000000000",
+ "gasPrice" : "1000000000",
+ "origin" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "99999999798",
+ "out" : "0x",
+ "post" : {
+ "cd1722f3947def4cf144679da39c4c32bdc35681" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x30600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0xcd1722f3947def4cf144679da39c4c32bdc35681"
+ }
+ }
+ },
+ "pre" : {
+ "cd1722f3947def4cf144679da39c4c32bdc35681" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x30600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "balance0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x73cd1722f3947def4cf144679da39c4c32bdc3568131600057",
+ "data" : "0x",
+ "gas" : "100000000000",
+ "gasPrice" : "1000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "99999999878",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x73cd1722f3947def4cf144679da39c4c32bdc3568131600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ },
+ "cd1722f3947def4cf144679da39c4c32bdc35681" : {
+ "balance" : "0",
+ "code" : "0x",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x73cd1722f3947def4cf144679da39c4c32bdc3568131600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "balance1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x730f572e5295c57f15886f9b263e2f6d2d6c7b5ec631600057",
+ "data" : "0x",
+ "gas" : "100000000000",
+ "gasPrice" : "1000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "99999999778",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x730f572e5295c57f15886f9b263e2f6d2d6c7b5ec631600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x0de0b6b3a7640000"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x730f572e5295c57f15886f9b263e2f6d2d6c7b5ec631600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "balanceAddress2" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x3031730f572e5295c57f15886f9b263e2f6d2d6c7b5ec6310e600057",
+ "data" : "0x",
+ "gas" : "100000000000",
+ "gasPrice" : "1000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "99999999756",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x3031730f572e5295c57f15886f9b263e2f6d2d6c7b5ec6310e600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x3031730f572e5295c57f15886f9b263e2f6d2d6c7b5ec6310e600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "balanceCaller3" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x333173cd1722f3947def4cf144679da39c4c32bdc35681310e600057",
+ "data" : "0x",
+ "gas" : "100000000000",
+ "gasPrice" : "1000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "99999999756",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x333173cd1722f3947def4cf144679da39c4c32bdc35681310e600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ },
+ "cd1722f3947def4cf144679da39c4c32bdc35681" : {
+ "balance" : "0",
+ "code" : "0x",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x333173cd1722f3947def4cf144679da39c4c32bdc35681310e600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "calldatacopy0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x60026001600037600053600057",
+ "data" : "0x01234567890abcdef01234567890abcdef",
+ "gas" : "100000000000",
+ "gasPrice" : "1000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "99999999792",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60026001600037600053600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x2345000000000000000000000000000000000000000000000000000000000000"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60026001600037600053600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "calldatacopy1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x60016001600037600053600057",
+ "data" : "0x01234567890abcdef01234567890abcdef",
+ "gas" : "100000000000",
+ "gasPrice" : "1000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "99999999792",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60016001600037600053600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x2300000000000000000000000000000000000000000000000000000000000000"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60016001600037600053600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "calldatacopy2" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x60006001600037600053600057",
+ "data" : "0x01234567890abcdef01234567890abcdef",
+ "gas" : "100000000000",
+ "gasPrice" : "1000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "99999999892",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60006001600037600053600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60006001600037600053600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "calldataload0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600035600057",
+ "data" : "0x0256",
+ "gas" : "100000000000",
+ "gasPrice" : "1000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "99999999797",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600035600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x0256000000000000000000000000000000000000000000000000000000000000"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600035600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "calldataload1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600135600057",
+ "data" : "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff23",
+ "gas" : "100000000000",
+ "gasPrice" : "1000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "99999999797",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600135600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff23"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600135600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "calldataload2" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600535600057",
+ "data" : "0x0123456789abcdef0000000000000000000000000000000000000000000000000024",
+ "gas" : "100000000000",
+ "gasPrice" : "1000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "99999999797",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600535600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0xabcdef0000000000000000000000000000000000000000000000000024000000"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600535600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "calldatasize0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x36600057",
+ "data" : "0x0256",
+ "gas" : "100000000000",
+ "gasPrice" : "1000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "99999999798",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x36600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x02"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x36600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "calldatasize1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x36600057",
+ "data" : "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff23",
+ "gas" : "100000000000",
+ "gasPrice" : "1000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "99999999798",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x36600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x21"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x36600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "calldatasize2" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x36600057",
+ "data" : "0x230000000000000000000000000000000000000000000000000000000000000023",
+ "gas" : "100000000000",
+ "gasPrice" : "1000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "99999999798",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x36600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x21"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x36600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "caller" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x33600057",
+ "data" : "0x",
+ "gas" : "100000000000",
+ "gasPrice" : "1000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "99999999798",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x33600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0xcd1722f3947def4cf144679da39c4c32bdc35681"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x33600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "callvalue" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x34600057",
+ "data" : "0x",
+ "gas" : "100000000000",
+ "gasPrice" : "1000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "99999999798",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x34600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x0de0b6b3a7640000"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x34600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "codecopy0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x60056000600039600053600057",
+ "data" : "0x01234567890abcdef01234567890abcdef",
+ "gas" : "100000000000",
+ "gasPrice" : "1000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "99999999792",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60056000600039600053600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x6005600060000000000000000000000000000000000000000000000000000000"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60056000600039600053600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "codecopy1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x386000600039600053600057",
+ "data" : "0x01234567890abcdef01234567890abcdef",
+ "gas" : "100000000000",
+ "gasPrice" : "1000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "99999999792",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x386000600039600053600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x3860006000396000536000570000000000000000000000000000000000000000"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x386000600039600053600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "codesize" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x38600057",
+ "data" : "0x01234567890abcdef01234567890abcdef",
+ "gas" : "100000000000",
+ "gasPrice" : "1000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "99999999798",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x38600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x04"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x38600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "extcodecopy0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x333b60006000333c600053600057",
+ "data" : "0x01234567890abcdef01234567890abcdef",
+ "gas" : "100000000000",
+ "gasPrice" : "123456789",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "99999999790",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x333b60006000333c600053600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x6005600057000000000000000000000000000000000000000000000000000000"
+ }
+ },
+ "cd1722f3947def4cf144679da39c4c32bdc35681" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6005600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x333b60006000333c600053600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ },
+ "cd1722f3947def4cf144679da39c4c32bdc35681" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6005600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "extcodesize0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x38333b0e600057",
+ "data" : "0x01234567890abcdef01234567890abcdef",
+ "gas" : "100000000000",
+ "gasPrice" : "123456789",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "99999999795",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x38333b0e600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ },
+ "cd1722f3947def4cf144679da39c4c32bdc35681" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x38333b0e600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x38333b0e600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ },
+ "cd1722f3947def4cf144679da39c4c32bdc35681" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x38333b0e600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "extcodesize1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "caller" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "code" : "0x333b600057",
+ "data" : "0x01234567890abcdef01234567890abcdef",
+ "gas" : "100000000000",
+ "gasPrice" : "123456789",
+ "origin" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "99999999797",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x38600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ },
+ "cd1722f3947def4cf144679da39c4c32bdc35681" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x333b600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x04"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x38600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ },
+ "cd1722f3947def4cf144679da39c4c32bdc35681" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x333b600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "gasprice" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x3a600057",
+ "data" : "0x01234567890abcdef01234567890abcdef",
+ "gas" : "100000000000",
+ "gasPrice" : "123456789",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "99999999798",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x3a600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x075bcd15"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x3a600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "origin" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x32600057",
+ "data" : "0x",
+ "gas" : "100000000000",
+ "gasPrice" : "1000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "99999999798",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x32600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0xcd1722f3947def4cf144679da39c4c32bdc35681"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x32600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/tests/files/vmtests/vmIOandFlowOperationsTest.json b/tests/files/vmtests/vmIOandFlowOperationsTest.json
new file mode 100644
index 0000000000000000000000000000000000000000..c5034754a8d4fbff724b5942073b5e944c4dd52f
--- /dev/null
+++ b/tests/files/vmtests/vmIOandFlowOperationsTest.json
@@ -0,0 +1,1372 @@
+{
+ "dupAt51doesNotExistAnymore" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600260035157",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9998",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600260035157",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600260035157",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "gas0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x64ffffffffff60005461eeee605a545c600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9788",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x64ffffffffff60005461eeee605a545c600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x2705"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x64ffffffffff60005461eeee605a545c600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "gas1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x5c600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9798",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x5c600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x270f"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x5c600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "jump0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x60236007586001600257",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9997",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60236007586001600257",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60236007586001600257",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "jump0_foreverOutOfGas" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6023600058",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "0",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6023600058",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6023600058",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "jump0_jumpdest0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x602360085860015d600257",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x602360085860015d600257",
+ "nonce" : "0",
+ "storage" : {
+ "0x02" : "0x23"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x602360085860015d600257",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "jump0_jumpdest1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x602360075860015d600257",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9997",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x602360075860015d600257",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x602360075860015d600257",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "jumpi0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x602360016009596001600257",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9996",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x602360016009596001600257",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x602360016009596001600257",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "jumpi1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x602360006009596001600257",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9794",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x602360006009596001600257",
+ "nonce" : "0",
+ "storage" : {
+ "0x02" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x602360006009596001600257",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "jumpi1_jumpdest" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x60236001600a5960015d600257",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9795",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60236001600a5960015d600257",
+ "nonce" : "0",
+ "storage" : {
+ "0x02" : "0x23"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60236001600a5960015d600257",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "mloadError0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600053600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9896",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600053600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600053600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "mloadError1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6017600154600053600157",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9892",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6017600154600053600157",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6017600154600053600157",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "mloadOutOfGasError2" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6272482553600157",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "0",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6272482553600157",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6272482553600157",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "msize0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x60ff6000545b600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9794",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60ff6000545b600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x20"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60ff6000545b600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "msize1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x64ffffffffff6000545b600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9794",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x64ffffffffff6000545b600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x20"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x64ffffffffff6000545b600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "msize2" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x64ffffffffff60005461eeee6020545b600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9790",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x64ffffffffff60005461eeee6020545b600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x40"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x64ffffffffff60005461eeee6020545b600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "msize3" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x64ffffffffff60005461eeee605a545b600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9788",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x64ffffffffff60005461eeee605a545b600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x80"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x64ffffffffff60005461eeee605a545b600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "mstore0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff600154600153600157",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9792",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff600154600153600157",
+ "nonce" : "0",
+ "storage" : {
+ "0x01" : "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff600154600153600157",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "mstore1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff600201600154600153600157",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9790",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff600201600154600153600157",
+ "nonce" : "0",
+ "storage" : {
+ "0x01" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff600201600154600153600157",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "mstore8WordToBigError" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "10000",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "mstore8_0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff600155600153600157",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9792",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff600155600153600157",
+ "nonce" : "0",
+ "storage" : {
+ "0x01" : "0xff00000000000000000000000000000000000000000000000000000000000000"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff600155600153600157",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "mstore8_1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x60ff60015560ee600255600053600157",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9790",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60ff60015560ee600255600053600157",
+ "nonce" : "0",
+ "storage" : {
+ "0x01" : "0xffee0000000000000000000000000000000000000000000000000000000000"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60ff60015560ee600255600053600157",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "mstoreWordToBigError" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "10000",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "mstore_mload0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6017600054600053600157",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9793",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6017600054600053600157",
+ "nonce" : "0",
+ "storage" : {
+ "0x01" : "0x17"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6017600054600053600157",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "pc0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x5a600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9898",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x5a600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x5a600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "pc1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x60ff6000575a600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9696",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60ff6000575a600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x05"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60ff6000575a600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "pop0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6002600360045057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6002600360045057",
+ "nonce" : "0",
+ "storage" : {
+ "0x03" : "0x02"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6002600360045057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "pop1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x5060026003600457",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "10000",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x5060026003600457",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x5060026003600457",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "sstore_load_0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x60ff60005760ee600a57600056601457",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9374",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60ff60005760ee600a57600056601457",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0xff",
+ "0x0a" : "0xee",
+ "0x14" : "0xff"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60ff60005760ee600a57600056601457",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "sstore_load_1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x60ff60005760ee600a57606456601457",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9474",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60ff60005760ee600a57606456601457",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0xff",
+ "0x0a" : "0xee"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60ff60005760ee600a57606456601457",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "sstore_load_2" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x60ff60005760ee60015760dd600257600156600a57600256601457",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "8950",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60ff60005760ee60015760dd600257600156600a57600256601457",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0xff",
+ "0x01" : "0xee",
+ "0x02" : "0xdd",
+ "0x0a" : "0xee",
+ "0x14" : "0xdd"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60ff60005760ee60015760dd600257600156600a57600256601457",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "swapAt52doesNotExistAnymore" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600260035257",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9998",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600260035257",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600260035257",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/tests/files/vmtests/vmPushDupSwapTest.json b/tests/files/vmtests/vmPushDupSwapTest.json
new file mode 100644
index 0000000000000000000000000000000000000000..f7fcb335dc777307b2d8a79487134e7c04ec99ff
--- /dev/null
+++ b/tests/files/vmtests/vmPushDupSwapTest.json
@@ -0,0 +1,2880 @@
+{
+ "dup1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7f10112233445566778899aabbccddeeff00112233445566778899aabbccddeeff80600357",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9797",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7f10112233445566778899aabbccddeeff00112233445566778899aabbccddeeff80600357",
+ "nonce" : "0",
+ "storage" : {
+ "0x03" : "0x10112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7f10112233445566778899aabbccddeeff00112233445566778899aabbccddeeff80600357",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "dup10" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600a60096008600760066005600460036002600189600357",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9788",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600a60096008600760066005600460036002600189600357",
+ "nonce" : "0",
+ "storage" : {
+ "0x03" : "0x0a"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600a60096008600760066005600460036002600189600357",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "dup11" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600b600a6009600860076006600560046003600260018a600357",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9787",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600b600a6009600860076006600560046003600260018a600357",
+ "nonce" : "0",
+ "storage" : {
+ "0x03" : "0x0b"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600b600a6009600860076006600560046003600260018a600357",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "dup12" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600c600b600a6009600860076006600560046003600260018b600357",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9786",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600c600b600a6009600860076006600560046003600260018b600357",
+ "nonce" : "0",
+ "storage" : {
+ "0x03" : "0x0c"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600c600b600a6009600860076006600560046003600260018b600357",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "dup13" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600d600c600b600a6009600860076006600560046003600260018c600357",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9785",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600d600c600b600a6009600860076006600560046003600260018c600357",
+ "nonce" : "0",
+ "storage" : {
+ "0x03" : "0x0d"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600d600c600b600a6009600860076006600560046003600260018c600357",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "dup14" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600e600d600c600b600a6009600860076006600560046003600260018d600357",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9784",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600e600d600c600b600a6009600860076006600560046003600260018d600357",
+ "nonce" : "0",
+ "storage" : {
+ "0x03" : "0x0e"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600e600d600c600b600a6009600860076006600560046003600260018d600357",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "dup15" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600f600e600d600c600b600a6009600860076006600560046003600260018e600357",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9783",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600f600e600d600c600b600a6009600860076006600560046003600260018e600357",
+ "nonce" : "0",
+ "storage" : {
+ "0x03" : "0x0f"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600f600e600d600c600b600a6009600860076006600560046003600260018e600357",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "dup16" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6010600f600e600d600c600b600a6009600860076006600560046003600260018f600357",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9782",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6010600f600e600d600c600b600a6009600860076006600560046003600260018f600357",
+ "nonce" : "0",
+ "storage" : {
+ "0x03" : "0x10"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6010600f600e600d600c600b600a6009600860076006600560046003600260018f600357",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "dup2" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6002600181600357",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6002600181600357",
+ "nonce" : "0",
+ "storage" : {
+ "0x03" : "0x02"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6002600181600357",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "dup2error" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7f10112233445566778899aabbccddeeff00112233445566778899aabbccddeeff81600357",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9999",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7f10112233445566778899aabbccddeeff00112233445566778899aabbccddeeff81600357",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7f10112233445566778899aabbccddeeff00112233445566778899aabbccddeeff81600357",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "dup3" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x60036002600182600357",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9795",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60036002600182600357",
+ "nonce" : "0",
+ "storage" : {
+ "0x03" : "0x03"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60036002600182600357",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "dup4" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600460036002600183600357",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9794",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600460036002600183600357",
+ "nonce" : "0",
+ "storage" : {
+ "0x03" : "0x04"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600460036002600183600357",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "dup5" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6005600460036002600184600357",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9793",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6005600460036002600184600357",
+ "nonce" : "0",
+ "storage" : {
+ "0x03" : "0x05"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6005600460036002600184600357",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "dup6" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x60066005600460036002600185600357",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9792",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60066005600460036002600185600357",
+ "nonce" : "0",
+ "storage" : {
+ "0x03" : "0x06"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60066005600460036002600185600357",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "dup7" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600760066005600460036002600186600357",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9791",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600760066005600460036002600186600357",
+ "nonce" : "0",
+ "storage" : {
+ "0x03" : "0x07"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600760066005600460036002600186600357",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "dup8" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6008600760066005600460036002600187600357",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9790",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6008600760066005600460036002600187600357",
+ "nonce" : "0",
+ "storage" : {
+ "0x03" : "0x08"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6008600760066005600460036002600187600357",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "dup9" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x60096008600760066005600460036002600188600357",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9789",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60096008600760066005600460036002600188600357",
+ "nonce" : "0",
+ "storage" : {
+ "0x03" : "0x09"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60096008600760066005600460036002600188600357",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "push1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x60ff600357",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9798",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60ff600357",
+ "nonce" : "0",
+ "storage" : {
+ "0x03" : "0xff"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60ff600357",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "push10" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6966778899aabbccddeeff600357",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9798",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6966778899aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ "0x03" : "0x66778899aabbccddeeff"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6966778899aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "push11" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6a5566778899aabbccddeeff600357",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9798",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6a5566778899aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ "0x03" : "0x5566778899aabbccddeeff"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6a5566778899aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "push12" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6b445566778899aabbccddeeff600357",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9798",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6b445566778899aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ "0x03" : "0x445566778899aabbccddeeff"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6b445566778899aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "push13" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6c33445566778899aabbccddeeff600357",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9798",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6c33445566778899aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ "0x03" : "0x33445566778899aabbccddeeff"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6c33445566778899aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "push14" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6d2233445566778899aabbccddeeff600357",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9798",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6d2233445566778899aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ "0x03" : "0x2233445566778899aabbccddeeff"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6d2233445566778899aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "push15" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6e112233445566778899aabbccddeeff600357",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9798",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6e112233445566778899aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ "0x03" : "0x112233445566778899aabbccddeeff"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6e112233445566778899aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "push16" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6f10112233445566778899aabbccddeeff600357",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9798",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6f10112233445566778899aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ "0x03" : "0x10112233445566778899aabbccddeeff"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6f10112233445566778899aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "push17" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x70ff00112233445566778899aabbccddeeff600357",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9798",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x70ff00112233445566778899aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ "0x03" : "0xff00112233445566778899aabbccddeeff"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x70ff00112233445566778899aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "push18" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x71eeff00112233445566778899aabbccddeeff600357",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9798",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x71eeff00112233445566778899aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ "0x03" : "0xeeff00112233445566778899aabbccddeeff"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x71eeff00112233445566778899aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "push19" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x72ddeeff00112233445566778899aabbccddeeff600357",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9798",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x72ddeeff00112233445566778899aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ "0x03" : "0xddeeff00112233445566778899aabbccddeeff"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x72ddeeff00112233445566778899aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "push2" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x61eeff600357",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9798",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x61eeff600357",
+ "nonce" : "0",
+ "storage" : {
+ "0x03" : "0xeeff"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x61eeff600357",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "push20" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x73ccddeeff00112233445566778899aabbccddeeff600357",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9798",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x73ccddeeff00112233445566778899aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ "0x03" : "0xccddeeff00112233445566778899aabbccddeeff"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x73ccddeeff00112233445566778899aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "push21" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x74bbccddeeff00112233445566778899aabbccddeeff600357",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9798",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x74bbccddeeff00112233445566778899aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ "0x03" : "0xbbccddeeff00112233445566778899aabbccddeeff"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x74bbccddeeff00112233445566778899aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "push22" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x75aabbccddeeff00112233445566778899aabbccddeeff600357",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9798",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x75aabbccddeeff00112233445566778899aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ "0x03" : "0xaabbccddeeff00112233445566778899aabbccddeeff"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x75aabbccddeeff00112233445566778899aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "push23" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7699aabbccddeeff00112233445566778899aabbccddeeff600357",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9798",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7699aabbccddeeff00112233445566778899aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ "0x03" : "0x99aabbccddeeff00112233445566778899aabbccddeeff"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7699aabbccddeeff00112233445566778899aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "push24" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x778899aabbccddeeff00112233445566778899aabbccddeeff600357",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9798",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x778899aabbccddeeff00112233445566778899aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ "0x03" : "0x8899aabbccddeeff00112233445566778899aabbccddeeff"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x778899aabbccddeeff00112233445566778899aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "push25" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x78778899aabbccddeeff00112233445566778899aabbccddeeff600357",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9798",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x78778899aabbccddeeff00112233445566778899aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ "0x03" : "0x778899aabbccddeeff00112233445566778899aabbccddeeff"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x78778899aabbccddeeff00112233445566778899aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "push26" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7966778899aabbccddeeff00112233445566778899aabbccddeeff600357",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9798",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7966778899aabbccddeeff00112233445566778899aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ "0x03" : "0x66778899aabbccddeeff00112233445566778899aabbccddeeff"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7966778899aabbccddeeff00112233445566778899aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "push27" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7a5566778899aabbccddeeff00112233445566778899aabbccddeeff600357",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9798",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7a5566778899aabbccddeeff00112233445566778899aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ "0x03" : "0x5566778899aabbccddeeff00112233445566778899aabbccddeeff"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7a5566778899aabbccddeeff00112233445566778899aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "push28" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7b445566778899aabbccddeeff00112233445566778899aabbccddeeff600357",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9798",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7b445566778899aabbccddeeff00112233445566778899aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ "0x03" : "0x445566778899aabbccddeeff00112233445566778899aabbccddeeff"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7b445566778899aabbccddeeff00112233445566778899aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "push29" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7c33445566778899aabbccddeeff00112233445566778899aabbccddeeff600357",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9798",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7c33445566778899aabbccddeeff00112233445566778899aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ "0x03" : "0x33445566778899aabbccddeeff00112233445566778899aabbccddeeff"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7c33445566778899aabbccddeeff00112233445566778899aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "push3" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x62ddeeff600357",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9798",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x62ddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ "0x03" : "0xddeeff"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x62ddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "push30" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7d2233445566778899aabbccddeeff00112233445566778899aabbccddeeff600357",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9798",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7d2233445566778899aabbccddeeff00112233445566778899aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ "0x03" : "0x2233445566778899aabbccddeeff00112233445566778899aabbccddeeff"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7d2233445566778899aabbccddeeff00112233445566778899aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "push31" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7e112233445566778899aabbccddeeff00112233445566778899aabbccddeeff600357",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9798",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7e112233445566778899aabbccddeeff00112233445566778899aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ "0x03" : "0x112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7e112233445566778899aabbccddeeff00112233445566778899aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "push32" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7f10112233445566778899aabbccddeeff00112233445566778899aabbccddeeff600357",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9798",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7f10112233445566778899aabbccddeeff00112233445566778899aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ "0x03" : "0x10112233445566778899aabbccddeeff00112233445566778899aabbccddeeff"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7f10112233445566778899aabbccddeeff00112233445566778899aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "push32error" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7fff10112233445566778899aabbccddeeff00112233445566778899aabbccddeeff600357",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9999",
+ "out" : "0x",
+ "post" : {
+ "bbccddeeff00112233445566778899aabbccddee" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fff10112233445566778899aabbccddeeff00112233445566778899aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "push4" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x63ccddeeff600357",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9798",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x63ccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ "0x03" : "0xccddeeff"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x63ccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "push5" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x64bbccddeeff600357",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9798",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x64bbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ "0x03" : "0xbbccddeeff"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x64bbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "push6" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x65aabbccddeeff600357",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9798",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x65aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ "0x03" : "0xaabbccddeeff"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x65aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "push7" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6699aabbccddeeff600357",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9798",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6699aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ "0x03" : "0x99aabbccddeeff"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6699aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "push8" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x678899aabbccddeeff600357",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9798",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x678899aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ "0x03" : "0x8899aabbccddeeff"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x678899aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "push9" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x68778899aabbccddeeff600357",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9798",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x68778899aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ "0x03" : "0x778899aabbccddeeff"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x68778899aabbccddeeff600357",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "swap1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7f10112233445566778899aabbccddeeff00112233445566778899aabbccddeeff60039057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9797",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7f10112233445566778899aabbccddeeff00112233445566778899aabbccddeeff60039057",
+ "nonce" : "0",
+ "storage" : {
+ "0x10112233445566778899aabbccddeeff00112233445566778899aabbccddeeff" : "0x03"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7f10112233445566778899aabbccddeeff00112233445566778899aabbccddeeff60039057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "swap10" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600a60096008600760066005600460036002600160039957",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9788",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600a60096008600760066005600460036002600160039957",
+ "nonce" : "0",
+ "storage" : {
+ "0x0a" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600a60096008600760066005600460036002600160039957",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "swap11" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600b600a60096008600760066005600460036002600160039a57",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9787",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600b600a60096008600760066005600460036002600160039a57",
+ "nonce" : "0",
+ "storage" : {
+ "0x0b" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600b600a60096008600760066005600460036002600160039a57",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "swap12" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600c600b600a60096008600760066005600460036002600160039b57",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9786",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600c600b600a60096008600760066005600460036002600160039b57",
+ "nonce" : "0",
+ "storage" : {
+ "0x0c" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600c600b600a60096008600760066005600460036002600160039b57",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "swap13" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600d600c600b600a60096008600760066005600460036002600160039c57",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9785",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600d600c600b600a60096008600760066005600460036002600160039c57",
+ "nonce" : "0",
+ "storage" : {
+ "0x0d" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600d600c600b600a60096008600760066005600460036002600160039c57",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "swap14" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600e600d600c600b600a60096008600760066005600460036002600160039d57",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9784",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600e600d600c600b600a60096008600760066005600460036002600160039d57",
+ "nonce" : "0",
+ "storage" : {
+ "0x0e" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600e600d600c600b600a60096008600760066005600460036002600160039d57",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "swap15" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600f600e600d600c600b600a60096008600760066005600460036002600160039e57",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9783",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600f600e600d600c600b600a60096008600760066005600460036002600160039e57",
+ "nonce" : "0",
+ "storage" : {
+ "0x0f" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600f600e600d600c600b600a60096008600760066005600460036002600160039e57",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "swap16" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6010600f600e600d600c600b600a60096008600760066005600460036002600160039f57",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9782",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6010600f600e600d600c600b600a60096008600760066005600460036002600160039f57",
+ "nonce" : "0",
+ "storage" : {
+ "0x10" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6010600f600e600d600c600b600a60096008600760066005600460036002600160039f57",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "swap2" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6002600160039157",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9796",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6002600160039157",
+ "nonce" : "0",
+ "storage" : {
+ "0x02" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6002600160039157",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "swap2error" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7f10112233445566778899aabbccddeeff00112233445566778899aabbccddeeff60039157",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9998",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7f10112233445566778899aabbccddeeff00112233445566778899aabbccddeeff60039157",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7f10112233445566778899aabbccddeeff00112233445566778899aabbccddeeff60039157",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "swap3" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x60036002600160039257",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9795",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60036002600160039257",
+ "nonce" : "0",
+ "storage" : {
+ "0x03" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60036002600160039257",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "swap4" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600460036002600160039357",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9794",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600460036002600160039357",
+ "nonce" : "0",
+ "storage" : {
+ "0x04" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600460036002600160039357",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "swap5" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6005600460036002600160039457",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9793",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6005600460036002600160039457",
+ "nonce" : "0",
+ "storage" : {
+ "0x05" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6005600460036002600160039457",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "swap6" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x60066005600460036002600160039557",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9792",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60066005600460036002600160039557",
+ "nonce" : "0",
+ "storage" : {
+ "0x06" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60066005600460036002600160039557",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "swap7" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600760066005600460036002600160039657",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9791",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600760066005600460036002600160039657",
+ "nonce" : "0",
+ "storage" : {
+ "0x07" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600760066005600460036002600160039657",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "swap8" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6008600760066005600460036002600160039757",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9790",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6008600760066005600460036002600160039757",
+ "nonce" : "0",
+ "storage" : {
+ "0x08" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6008600760066005600460036002600160039757",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "swap9" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x60096008600760066005600460036002600160039857",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9789",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60096008600760066005600460036002600160039857",
+ "nonce" : "0",
+ "storage" : {
+ "0x09" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60096008600760066005600460036002600160039857",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/tests/files/vmtests/vmSha3Test.json b/tests/files/vmtests/vmSha3Test.json
new file mode 100644
index 0000000000000000000000000000000000000000..54ba645a90bad51417ba5cb38f77c636a97253d0
--- /dev/null
+++ b/tests/files/vmtests/vmSha3Test.json
@@ -0,0 +1,173 @@
+{
+ "sha3_0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6000600020600057",
+ "data" : "0x",
+ "gas" : "100000000000",
+ "gasPrice" : "1000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "99999999777",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6000600020600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6000600020600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "sha3_1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6005600420600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9776",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6005600420600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0xc41589e7559804ea4a2080dad19d876a024ccb05117835447d72ce08c1d020ec"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6005600420600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "sha3_2" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600a600a20600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9776",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600a600a20600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x6bd2dd6bd408cbee33429358bf24fdc64612fbf8b1b4db604518f40ffd34b607"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600a600a20600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "sha3_3" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6064640fffffffff20600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "0",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6064640fffffffff20600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6064640fffffffff20600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/tests/files/vmtests/vmSystemOperationsTest.json b/tests/files/vmtests/vmSystemOperationsTest.json
new file mode 100644
index 0000000000000000000000000000000000000000..920cb233128bac538ad768280335691acdb44cfa
--- /dev/null
+++ b/tests/files/vmtests/vmSystemOperationsTest.json
@@ -0,0 +1,1650 @@
+{
+ "ABAcalls0" : {
+ "callcreates" : [
+ {
+ "data" : "0x",
+ "destination" : "945304eb96065b2a98b57a48a06ae28d285a71b5",
+ "gasLimit" : "1000",
+ "value" : "24"
+ }
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "10000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6000600060006000601873945304eb96065b2a98b57a48a06ae28d285a71b56103e8f15a57",
+ "data" : "0x",
+ "gas" : "10000000000000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "100000"
+ },
+ "gas" : "9999999999042",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "999999999999999999",
+ "code" : "0x6000600060006000601873945304eb96065b2a98b57a48a06ae28d285a71b56103e8f15a57",
+ "nonce" : "0",
+ "storage" : {
+ "0x23" : "0x01"
+ }
+ },
+ "945304eb96065b2a98b57a48a06ae28d285a71b5" : {
+ "balance" : "24",
+ "code" : "0x60006000600060006017730f572e5295c57f15886f9b263e2f6d2d6c7b5ec66101f4f16001015a57",
+ "nonce" : "0",
+ "storage" : {
+ "0x26" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6000600060006000601873945304eb96065b2a98b57a48a06ae28d285a71b56103e8f15a57",
+ "nonce" : "0",
+ "storage" : {
+ }
+ },
+ "945304eb96065b2a98b57a48a06ae28d285a71b5" : {
+ "balance" : "23",
+ "code" : "0x60006000600060006017730f572e5295c57f15886f9b263e2f6d2d6c7b5ec66101f4f16001015a57",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "ABAcalls1" : {
+ "callcreates" : [
+ {
+ "data" : "0x",
+ "destination" : "945304eb96065b2a98b57a48a06ae28d285a71b5",
+ "gasLimit" : "9999999998992",
+ "value" : "24"
+ }
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "10000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6000600060006000601873945304eb96065b2a98b57a48a06ae28d285a71b56103e85c03f15a57",
+ "data" : "0x",
+ "gas" : "10000000000000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "100000"
+ },
+ "gas" : "898727",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "999999999999999488",
+ "code" : "0x6000600060006000601873945304eb96065b2a98b57a48a06ae28d285a71b56103e85c03f15a57",
+ "nonce" : "0",
+ "storage" : {
+ "0x25" : "0x01"
+ }
+ },
+ "945304eb96065b2a98b57a48a06ae28d285a71b5" : {
+ "balance" : "535",
+ "code" : "0x60006000600060006017730f572e5295c57f15886f9b263e2f6d2d6c7b5ec66103e85c03f16001015a57",
+ "nonce" : "0",
+ "storage" : {
+ "0x28" : "0x02"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6000600060006000601873945304eb96065b2a98b57a48a06ae28d285a71b56103e85c03f15a57",
+ "nonce" : "0",
+ "storage" : {
+ }
+ },
+ "945304eb96065b2a98b57a48a06ae28d285a71b5" : {
+ "balance" : "23",
+ "code" : "0x60006000600060006017730f572e5295c57f15886f9b263e2f6d2d6c7b5ec66103e85c03f16001015a57",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "ABAcallsSuicide0" : {
+ "callcreates" : [
+ {
+ "data" : "0x",
+ "destination" : "945304eb96065b2a98b57a48a06ae28d285a71b5",
+ "gasLimit" : "1000",
+ "value" : "24"
+ }
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "10000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6000600060006000601873945304eb96065b2a98b57a48a06ae28d285a71b56103e8f15a5773945304eb96065b2a98b57a48a06ae28d285a71b5ff",
+ "data" : "0x",
+ "gas" : "10000000000000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "100000"
+ },
+ "gas" : "9999999999041",
+ "out" : "0x",
+ "post" : {
+ "945304eb96065b2a98b57a48a06ae28d285a71b5" : {
+ "balance" : "1000000000000000023",
+ "code" : "0x60006000600060006017730f572e5295c57f15886f9b263e2f6d2d6c7b5ec66101f4f16001015a57",
+ "nonce" : "0",
+ "storage" : {
+ "0x26" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6000600060006000601873945304eb96065b2a98b57a48a06ae28d285a71b56103e8f15a5773945304eb96065b2a98b57a48a06ae28d285a71b5ff",
+ "nonce" : "0",
+ "storage" : {
+ }
+ },
+ "945304eb96065b2a98b57a48a06ae28d285a71b5" : {
+ "balance" : "23",
+ "code" : "0x60006000600060006017730f572e5295c57f15886f9b263e2f6d2d6c7b5ec66101f4f16001015a57",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "ABAcallsSuicide1" : {
+ "callcreates" : [
+ {
+ "data" : "0x",
+ "destination" : "945304eb96065b2a98b57a48a06ae28d285a71b5",
+ "gasLimit" : "1000",
+ "value" : "24"
+ }
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "10000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6000600060006000601873945304eb96065b2a98b57a48a06ae28d285a71b56103e8f15a57",
+ "data" : "0x",
+ "gas" : "10000000000000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "100000"
+ },
+ "gas" : "9999999999041",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000023",
+ "code" : "0x6000600060006000601873945304eb96065b2a98b57a48a06ae28d285a71b56103e8f15a57",
+ "nonce" : "0",
+ "storage" : {
+ "0x23" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x6000600060006000601873945304eb96065b2a98b57a48a06ae28d285a71b56103e8f15a57",
+ "nonce" : "0",
+ "storage" : {
+ }
+ },
+ "945304eb96065b2a98b57a48a06ae28d285a71b5" : {
+ "balance" : "23",
+ "code" : "0x60006000600060006017730f572e5295c57f15886f9b263e2f6d2d6c7b5ec66101f4f16001015a57730f572e5295c57f15886f9b263e2f6d2d6c7b5ec6ff",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "CallRecursiveBomb" : {
+ "callcreates" : [
+ {
+ "data" : "0x",
+ "destination" : "945304eb96065b2a98b57a48a06ae28d285a71b5",
+ "gasLimit" : "100000",
+ "value" : "23"
+ }
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "10000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x6000600060006000601773945304eb96065b2a98b57a48a06ae28d285a71b5620186a0f1",
+ "data" : "0x",
+ "gas" : "20000000",
+ "gasPrice" : "1",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "100000"
+ },
+ "gas" : "19928433",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "19999977",
+ "code" : "0x6000600060006000601773945304eb96065b2a98b57a48a06ae28d285a71b5620186a0f1",
+ "nonce" : "0",
+ "storage" : {
+ }
+ },
+ "945304eb96065b2a98b57a48a06ae28d285a71b5" : {
+ "balance" : "1000000000000000023",
+ "code" : "0x600160005601600057600060006000600060003060e05c03f1600157",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x0118",
+ "0x01" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "20000000",
+ "code" : "0x6000600060006000601773945304eb96065b2a98b57a48a06ae28d285a71b5620186a0f1",
+ "nonce" : "0",
+ "storage" : {
+ }
+ },
+ "945304eb96065b2a98b57a48a06ae28d285a71b5" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600160005601600057600060006000600060003060e05c03f1600157",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "CallToNameRegistrator0" : {
+ "callcreates" : [
+ {
+ "data" : "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa",
+ "destination" : "945304eb96065b2a98b57a48a06ae28d285a71b5",
+ "gasLimit" : "1000000",
+ "value" : "23"
+ }
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "10000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff6000547faaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa6020546000604060406000601773945304eb96065b2a98b57a48a06ae28d285a71b5620f4240f1600057",
+ "data" : "0x",
+ "gas" : "10000000000000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "100000"
+ },
+ "gas" : "9999999999535",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "999999999999999977",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff6000547faaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa6020546000604060406000601773945304eb96065b2a98b57a48a06ae28d285a71b5620f4240f1600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ },
+ "945304eb96065b2a98b57a48a06ae28d285a71b5" : {
+ "balance" : "46",
+ "code" : "0x600035560f600a59005d60203560003557",
+ "nonce" : "0",
+ "storage" : {
+ "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" : "0xaaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff6000547faaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa6020546000604060406000601773945304eb96065b2a98b57a48a06ae28d285a71b5620f4240f1600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ },
+ "945304eb96065b2a98b57a48a06ae28d285a71b5" : {
+ "balance" : "23",
+ "code" : "0x600035560f600a59005d60203560003557",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "CallToNameRegistratorNotMuchMemory0" : {
+ "callcreates" : [
+ {
+ "data" : "0xeeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00aaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa",
+ "destination" : "945304eb96065b2a98b57a48a06ae28d285a71b5",
+ "gasLimit" : "500",
+ "value" : "23"
+ }
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "10000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7feeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff006000547faaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa6020546000620f120660406000601773945304eb96065b2a98b57a48a06ae28d285a71b56101f4f1600057",
+ "data" : "0x",
+ "gas" : "1000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "100000"
+ },
+ "gas" : "535",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "999999999999999977",
+ "code" : "0x7feeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff006000547faaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa6020546000620f120660406000601773945304eb96065b2a98b57a48a06ae28d285a71b56101f4f1600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ },
+ "945304eb96065b2a98b57a48a06ae28d285a71b5" : {
+ "balance" : "46",
+ "code" : "0x600035560f600a59005d60203560003557",
+ "nonce" : "0",
+ "storage" : {
+ "0xeeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00" : "0xaaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7feeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff006000547faaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa6020546000620f120660406000601773945304eb96065b2a98b57a48a06ae28d285a71b56101f4f1600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ },
+ "945304eb96065b2a98b57a48a06ae28d285a71b5" : {
+ "balance" : "23",
+ "code" : "0x600035560f600a59005d60203560003557",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "CallToNameRegistratorNotMuchMemory1" : {
+ "callcreates" : [
+ {
+ "data" : "0x",
+ "destination" : "945304eb96065b2a98b57a48a06ae28d285a71b5",
+ "gasLimit" : "500",
+ "value" : "23"
+ }
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "10000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7feeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff006000547faaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa602054600060406000620f1206601773945304eb96065b2a98b57a48a06ae28d285a71b56101f4f1600057",
+ "data" : "0x",
+ "gas" : "1000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "100000"
+ },
+ "gas" : "635",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "999999999999999977",
+ "code" : "0x7feeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff006000547faaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa602054600060406000620f1206601773945304eb96065b2a98b57a48a06ae28d285a71b56101f4f1600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ },
+ "945304eb96065b2a98b57a48a06ae28d285a71b5" : {
+ "balance" : "46",
+ "code" : "0x600035560f600a59005d60203560003557",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7feeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff006000547faaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa602054600060406000620f1206601773945304eb96065b2a98b57a48a06ae28d285a71b56101f4f1600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ },
+ "945304eb96065b2a98b57a48a06ae28d285a71b5" : {
+ "balance" : "23",
+ "code" : "0x600035560f600a59005d60203560003557",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "CallToNameRegistratorOutOfGas" : {
+ "callcreates" : [
+ {
+ "data" : "0xeeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00aaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa",
+ "destination" : "945304eb96065b2a98b57a48a06ae28d285a71b5",
+ "gasLimit" : "100",
+ "value" : "23"
+ }
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "10000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7feeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff006000547faaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa6020546000604060406000601773945304eb96065b2a98b57a48a06ae28d285a71b56064f1600057",
+ "data" : "0x",
+ "gas" : "1000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "100000"
+ },
+ "gas" : "764",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "999999999999999977",
+ "code" : "0x7feeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff006000547faaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa6020546000604060406000601773945304eb96065b2a98b57a48a06ae28d285a71b56064f1600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ },
+ "945304eb96065b2a98b57a48a06ae28d285a71b5" : {
+ "balance" : "46",
+ "code" : "0x600035560f600a59005d60203560003557",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7feeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff006000547faaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa6020546000604060406000601773945304eb96065b2a98b57a48a06ae28d285a71b56064f1600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ },
+ "945304eb96065b2a98b57a48a06ae28d285a71b5" : {
+ "balance" : "23",
+ "code" : "0x600035560f600a59005d60203560003557",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "CallToNameRegistratorTooMuchMemory0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "10000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7feeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff006000547faaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa602054600060406040633ade68b1601773945304eb96065b2a98b57a48a06ae28d285a71b56101f4f1600057",
+ "data" : "0x",
+ "gas" : "1000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "100000"
+ },
+ "gas" : "0",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7feeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff006000547faaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa602054600060406040633ade68b1601773945304eb96065b2a98b57a48a06ae28d285a71b56101f4f1600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ },
+ "945304eb96065b2a98b57a48a06ae28d285a71b5" : {
+ "balance" : "23",
+ "code" : "0x600035560f600a59005d60203560003557",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7feeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff006000547faaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa602054600060406040633ade68b1601773945304eb96065b2a98b57a48a06ae28d285a71b56101f4f1600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ },
+ "945304eb96065b2a98b57a48a06ae28d285a71b5" : {
+ "balance" : "23",
+ "code" : "0x600035560f600a59005d60203560003557",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "CallToNameRegistratorTooMuchMemory1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "10000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7feeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff006000547faaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa60205460006040629688d86000601773945304eb96065b2a98b57a48a06ae28d285a71b56101f4f1600057",
+ "data" : "0x",
+ "gas" : "1000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "100000"
+ },
+ "gas" : "0",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7feeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff006000547faaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa60205460006040629688d86000601773945304eb96065b2a98b57a48a06ae28d285a71b56101f4f1600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ },
+ "945304eb96065b2a98b57a48a06ae28d285a71b5" : {
+ "balance" : "23",
+ "code" : "0x600035560f600a59005d60203560003557",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7feeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff006000547faaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa60205460006040629688d86000601773945304eb96065b2a98b57a48a06ae28d285a71b56101f4f1600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ },
+ "945304eb96065b2a98b57a48a06ae28d285a71b5" : {
+ "balance" : "23",
+ "code" : "0x600035560f600a59005d60203560003557",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "CallToNameRegistratorTooMuchMemory2" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "10000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7feeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff006000547faaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa6020546001620f120660406000601773945304eb96065b2a98b57a48a06ae28d285a71b56101f4f1600057",
+ "data" : "0x",
+ "gas" : "1000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "100000"
+ },
+ "gas" : "0",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7feeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff006000547faaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa6020546001620f120660406000601773945304eb96065b2a98b57a48a06ae28d285a71b56101f4f1600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ },
+ "945304eb96065b2a98b57a48a06ae28d285a71b5" : {
+ "balance" : "23",
+ "code" : "0x600035560f600a59005d60203560003557",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7feeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff006000547faaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa6020546001620f120660406000601773945304eb96065b2a98b57a48a06ae28d285a71b56101f4f1600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ },
+ "945304eb96065b2a98b57a48a06ae28d285a71b5" : {
+ "balance" : "23",
+ "code" : "0x600035560f600a59005d60203560003557",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "CallToReturn1" : {
+ "callcreates" : [
+ {
+ "data" : "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa",
+ "destination" : "945304eb96065b2a98b57a48a06ae28d285a71b5",
+ "gasLimit" : "1000000",
+ "value" : "23"
+ }
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "10000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff6000547faaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa6020546002600060406000601773945304eb96065b2a98b57a48a06ae28d285a71b5620f4240f1600057",
+ "data" : "0x",
+ "gas" : "10000000000000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "100000"
+ },
+ "gas" : "9999999999555",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "999999999999999977",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff6000547faaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa6020546002600060406000601773945304eb96065b2a98b57a48a06ae28d285a71b5620f4240f1600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01"
+ }
+ },
+ "945304eb96065b2a98b57a48a06ae28d285a71b5" : {
+ "balance" : "46",
+ "code" : "0x6001600157603760005560026000f2",
+ "nonce" : "0",
+ "storage" : {
+ "0x01" : "0x01"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff6000547faaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa6020546002600060406000601773945304eb96065b2a98b57a48a06ae28d285a71b5620f4240f1600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ },
+ "945304eb96065b2a98b57a48a06ae28d285a71b5" : {
+ "balance" : "23",
+ "code" : "0x6001600157603760005560026000f2",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "PostToNameRegistrator0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "10000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff6000547faaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa6020546080",
+ "data" : "0x",
+ "gas" : "10000000000000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "100000"
+ },
+ "gas" : "9999999999991",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff6000547faaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa6020546080",
+ "nonce" : "0",
+ "storage" : {
+ }
+ },
+ "945304eb96065b2a98b57a48a06ae28d285a71b5" : {
+ "balance" : "23",
+ "code" : "0x600035560f600a59005d60203560003557",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff6000547faaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa6020546080",
+ "nonce" : "0",
+ "storage" : {
+ }
+ },
+ "945304eb96065b2a98b57a48a06ae28d285a71b5" : {
+ "balance" : "23",
+ "code" : "0x600035560f600a59005d60203560003557",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "PostToReturn1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "10000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff6000547faaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa6020546080",
+ "data" : "0x",
+ "gas" : "10000000000000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "100000"
+ },
+ "gas" : "9999999999991",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff6000547faaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa6020546080",
+ "nonce" : "0",
+ "storage" : {
+ }
+ },
+ "945304eb96065b2a98b57a48a06ae28d285a71b5" : {
+ "balance" : "23",
+ "code" : "0x603760005560026000f2",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff6000547faaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa6020546080",
+ "nonce" : "0",
+ "storage" : {
+ }
+ },
+ "945304eb96065b2a98b57a48a06ae28d285a71b5" : {
+ "balance" : "23",
+ "code" : "0x603760005560026000f2",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "TestNameRegistrator" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600035560f600a59005d60203560003557",
+ "data" : "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffafffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9771",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600035560f600a59005d60203560003557",
+ "nonce" : "0",
+ "storage" : {
+ "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa" : "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa"
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600035560f600a59005d60203560003557",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "callcodeToNameRegistrator0" : {
+ "callcreates" : [
+ {
+ "data" : "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa",
+ "destination" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "gasLimit" : "1000000",
+ "value" : "23"
+ }
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "10000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff6000547faaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa6020546000604060406000601773945304eb96065b2a98b57a48a06ae28d285a71b5620f4240f3600057",
+ "data" : "0x",
+ "gas" : "10000000000000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "100000"
+ },
+ "gas" : "9999999999535",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff6000547faaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa6020546000604060406000601773945304eb96065b2a98b57a48a06ae28d285a71b5620f4240f3600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01",
+ "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" : "0xaaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa"
+ }
+ },
+ "945304eb96065b2a98b57a48a06ae28d285a71b5" : {
+ "balance" : "23",
+ "code" : "0x600035560f600a59005d60203560003557",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff6000547faaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa6020546000604060406000601773945304eb96065b2a98b57a48a06ae28d285a71b5620f4240f3600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ },
+ "945304eb96065b2a98b57a48a06ae28d285a71b5" : {
+ "balance" : "23",
+ "code" : "0x600035560f600a59005d60203560003557",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "callcodeToReturn1" : {
+ "callcreates" : [
+ {
+ "data" : "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa",
+ "destination" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "gasLimit" : "500",
+ "value" : "23"
+ }
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "10000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff6000547faaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa6020546002600060406000601773945304eb96065b2a98b57a48a06ae28d285a71b56101f4f3600057",
+ "data" : "0x",
+ "gas" : "10000000000000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "100000"
+ },
+ "gas" : "9999999999555",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff6000547faaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa6020546002600060406000601773945304eb96065b2a98b57a48a06ae28d285a71b56101f4f3600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x01",
+ "0x01" : "0x01"
+ }
+ },
+ "945304eb96065b2a98b57a48a06ae28d285a71b5" : {
+ "balance" : "23",
+ "code" : "0x6001600157603760005560026000f2",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff6000547faaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa6020546002600060406000601773945304eb96065b2a98b57a48a06ae28d285a71b56101f4f3600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ },
+ "945304eb96065b2a98b57a48a06ae28d285a71b5" : {
+ "balance" : "23",
+ "code" : "0x6001600157603760005560026000f2",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "callstatelessToNameRegistrator0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "10000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff6000547faaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa6020546080600057",
+ "data" : "0x",
+ "gas" : "10000000000000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "100000"
+ },
+ "gas" : "9999999999790",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff6000547faaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa6020546080600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x80"
+ }
+ },
+ "945304eb96065b2a98b57a48a06ae28d285a71b5" : {
+ "balance" : "23",
+ "code" : "0x600035560f600a59005d60203560003557",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff6000547faaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa6020546080600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ },
+ "945304eb96065b2a98b57a48a06ae28d285a71b5" : {
+ "balance" : "23",
+ "code" : "0x600035560f600a59005d60203560003557",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "callstatelessToReturn1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "10000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff6000547faaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa6020546080600057",
+ "data" : "0x",
+ "gas" : "10000000000000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "100000"
+ },
+ "gas" : "9999999999790",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff6000547faaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa6020546080600057",
+ "nonce" : "0",
+ "storage" : {
+ "0x" : "0x80"
+ }
+ },
+ "945304eb96065b2a98b57a48a06ae28d285a71b5" : {
+ "balance" : "23",
+ "code" : "0x6001600157603760005560026000f2",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff6000547faaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffaa6020546080600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ },
+ "945304eb96065b2a98b57a48a06ae28d285a71b5" : {
+ "balance" : "23",
+ "code" : "0x6001600157603760005560026000f2",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "createNameRegistrator" : {
+ "callcreates" : [
+ {
+ "data" : "0x601080600c6000396000f200600035560f6009590060203560003557",
+ "destination" : "945304eb96065b2a98b57a48a06ae28d285a71b5",
+ "gasLimit" : "9893",
+ "value" : "23"
+ }
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7b601080600c6000396000f200600035560f6009590060203560003557600054601c60046017f0600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9684",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "999999999999999977",
+ "code" : "0x7b601080600c6000396000f200600035560f6009590060203560003557600054601c60046017f0600057",
+ "nonce" : "1",
+ "storage" : {
+ "0x" : "0x945304eb96065b2a98b57a48a06ae28d285a71b5"
+ }
+ },
+ "945304eb96065b2a98b57a48a06ae28d285a71b5" : {
+ "balance" : "23",
+ "code" : "0x600035560f6009590060203560003557",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x7b601080600c6000396000f200600035560f6009590060203560003557600054601c60046017f0600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "createNameRegistratorOutOfMemoryBonds0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7b601080600c6000396000f200600035560f6009590060203560003557600054601c650fffffffffff6017f0600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "100"
+ },
+ "gas" : "0",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "100",
+ "code" : "0x7b601080600c6000396000f200600035560f6009590060203560003557600054601c650fffffffffff6017f0600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "100",
+ "code" : "0x7b601080600c6000396000f200600035560f6009590060203560003557600054601c650fffffffffff6017f0600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "createNameRegistratorOutOfMemoryBonds1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7b601080600c6000396000f200600035560f600959006020356000355760005463ffffffff60046017f0600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "100"
+ },
+ "gas" : "0",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "100",
+ "code" : "0x7b601080600c6000396000f200600035560f600959006020356000355760005463ffffffff60046017f0600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "100",
+ "code" : "0x7b601080600c6000396000f200600035560f600959006020356000355760005463ffffffff60046017f0600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "createNameRegistratorValueTooHigh" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x7b601080600c6000396000f200600035560f6009590060203560003557600054601c600460e6f0600057",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "100"
+ },
+ "gas" : "9792",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "100",
+ "code" : "0x7b601080600c6000396000f200600035560f6009590060203560003557600054601c600460e6f0600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "100",
+ "code" : "0x7b601080600c6000396000f200600035560f6009590060203560003557600054601c600460e6f0600057",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "return0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "10000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "caller" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "code" : "0x603760005560016000f2",
+ "data" : "0xaa",
+ "gas" : "1000",
+ "gasPrice" : "100000000000000",
+ "origin" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "value" : "23"
+ },
+ "gas" : "993",
+ "out" : "0x37",
+ "post" : {
+ "cd1722f3947def4cf144679da39c4c32bdc35681" : {
+ "balance" : "23",
+ "code" : "0x603760005560016000f2",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "cd1722f3947def4cf144679da39c4c32bdc35681" : {
+ "balance" : "23",
+ "code" : "0x603760005560016000f2",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "return1" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "10000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "caller" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "code" : "0x603760005560026000f2",
+ "data" : "0xaa",
+ "gas" : "1000",
+ "gasPrice" : "100000000000000",
+ "origin" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "value" : "23"
+ },
+ "gas" : "993",
+ "out" : "0x3700",
+ "post" : {
+ "cd1722f3947def4cf144679da39c4c32bdc35681" : {
+ "balance" : "23",
+ "code" : "0x603760005560026000f2",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "cd1722f3947def4cf144679da39c4c32bdc35681" : {
+ "balance" : "23",
+ "code" : "0x603760005560026000f2",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "return2" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "10000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "caller" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "code" : "0x603760005560216000f2",
+ "data" : "0xaa",
+ "gas" : "1000",
+ "gasPrice" : "100000000000000",
+ "origin" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "value" : "23"
+ },
+ "gas" : "992",
+ "out" : "0x370000000000000000000000000000000000000000000000000000000000000000",
+ "post" : {
+ "cd1722f3947def4cf144679da39c4c32bdc35681" : {
+ "balance" : "23",
+ "code" : "0x603760005560216000f2",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "cd1722f3947def4cf144679da39c4c32bdc35681" : {
+ "balance" : "23",
+ "code" : "0x603760005560216000f2",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "suicide0" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "10000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x33ff",
+ "data" : "0x",
+ "gas" : "1000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "100000"
+ },
+ "gas" : "999",
+ "out" : "0x",
+ "post" : {
+ "cd1722f3947def4cf144679da39c4c32bdc35681" : {
+ "balance" : "1000000000000000023",
+ "code" : "0x600035560f600a59005d60203560003557",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x33ff",
+ "nonce" : "0",
+ "storage" : {
+ }
+ },
+ "cd1722f3947def4cf144679da39c4c32bdc35681" : {
+ "balance" : "23",
+ "code" : "0x600035560f600a59005d60203560003557",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "suicideNotExistingAccount" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "10000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x73aa1722f3947def4cf144679da39c4c32bdc35681ff",
+ "data" : "0x",
+ "gas" : "1000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "100000"
+ },
+ "gas" : "999",
+ "out" : "0x",
+ "post" : {
+ "aa1722f3947def4cf144679da39c4c32bdc35681" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x",
+ "nonce" : "0",
+ "storage" : {
+ }
+ },
+ "cd1722f3947def4cf144679da39c4c32bdc35681" : {
+ "balance" : "23",
+ "code" : "0x600035560f600a59005d60203560003557",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x73aa1722f3947def4cf144679da39c4c32bdc35681ff",
+ "nonce" : "0",
+ "storage" : {
+ }
+ },
+ "cd1722f3947def4cf144679da39c4c32bdc35681" : {
+ "balance" : "23",
+ "code" : "0x600035560f600a59005d60203560003557",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "suicideSendEtherToMe" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "10000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x30ff",
+ "data" : "0x",
+ "gas" : "1000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "100000"
+ },
+ "gas" : "999",
+ "out" : "0x",
+ "post" : {
+ "cd1722f3947def4cf144679da39c4c32bdc35681" : {
+ "balance" : "23",
+ "code" : "0x600035560f600a59005d60203560003557",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x30ff",
+ "nonce" : "0",
+ "storage" : {
+ }
+ },
+ "cd1722f3947def4cf144679da39c4c32bdc35681" : {
+ "balance" : "23",
+ "code" : "0x600035560f600a59005d60203560003557",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/tests/files/vmtests/vmtests.json b/tests/files/vmtests/vmtests.json
new file mode 100644
index 0000000000000000000000000000000000000000..a8803992e12f92ee7be1faa773c0e8809fd76326
--- /dev/null
+++ b/tests/files/vmtests/vmtests.json
@@ -0,0 +1,206 @@
+{
+ "arith" : {
+ "callcreates" : [
+ {
+ "data" : "0x",
+ "destination" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "gasLimit" : "9770",
+ "value" : "74"
+ }
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x600060006000600060026002600803036002600306600260020460046004600402026002600201010101013360c85c03f1",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9949",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "999999999999999926",
+ "code" : "0x600060006000600060026002600803036002600306600260020460046004600402026002600201010101013360c85c03f1",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x600060006000600060026002600803036002600306600260020460046004600402026002600201010101013360c85c03f1",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "boolean" : {
+ "callcreates" : [
+ {
+ "data" : "0x",
+ "destination" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "gasLimit" : "9786",
+ "value" : "2"
+ },
+ {
+ "data" : "0x",
+ "destination" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "gasLimit" : "9731",
+ "value" : "12"
+ },
+ {
+ "data" : "0x",
+ "destination" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "gasLimit" : "9694",
+ "value" : "13"
+ },
+ {
+ "data" : "0x",
+ "destination" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "gasLimit" : "9657",
+ "value" : "14"
+ }
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x60016001100f601b59600060006000600060023360c85c03f1505d60006001100f603659600060006000600060033360c85c03f1505d60016000100f605159600060006000600060043360c85c03f1505d60006000100f606c59600060006000600060053360c85c03f1505d60016001110f6087596000600060006000600c3360c85c03f1505d60006001110f60a2596000600060006000600d3360c85c03f1505d60016000110f60bd596000600060006000600e3360c85c03f1505d60006000110f60d8596000600060006000600f3360c85c03f1505d",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9828",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "999999999999999959",
+ "code" : "0x60016001100f601b59600060006000600060023360c85c03f1505d60006001100f603659600060006000600060033360c85c03f1505d60016000100f605159600060006000600060043360c85c03f1505d60006000100f606c59600060006000600060053360c85c03f1505d60016001110f6087596000600060006000600c3360c85c03f1505d60006001110f60a2596000600060006000600d3360c85c03f1505d60016000110f60bd596000600060006000600e3360c85c03f1505d60006000110f60d8596000600060006000600f3360c85c03f1505d",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60016001100f601b59600060006000600060023360c85c03f1505d60006001100f603659600060006000600060033360c85c03f1505d60016000100f605159600060006000600060043360c85c03f1505d60006000100f606c59600060006000600060053360c85c03f1505d60016001110f6087596000600060006000600c3360c85c03f1505d60006001110f60a2596000600060006000600d3360c85c03f1505d60016000110f60bd596000600060006000600e3360c85c03f1505d60006000110f60d8596000600060006000600f3360c85c03f1505d",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "mktx" : {
+ "callcreates" : [
+ {
+ "data" : "0x",
+ "destination" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "gasLimit" : "9792",
+ "value" : "500000000000000000"
+ }
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x60006000600060006706f05b59d3b200003360c85c03f1",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9971",
+ "out" : "0x",
+ "post" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "500000000000000000",
+ "code" : "0x60006000600060006706f05b59d3b200003360c85c03f1",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x60006000600060006706f05b59d3b200003360c85c03f1",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ },
+ "suicide" : {
+ "callcreates" : [
+ ],
+ "env" : {
+ "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentDifficulty" : "256",
+ "currentGasLimit" : "1000000",
+ "currentNumber" : "0",
+ "currentTimestamp" : "1",
+ "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6"
+ },
+ "exec" : {
+ "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+ "caller" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "code" : "0x33ff",
+ "data" : "0x",
+ "gas" : "10000",
+ "gasPrice" : "100000000000000",
+ "origin" : "cd1722f3947def4cf144679da39c4c32bdc35681",
+ "value" : "1000000000000000000"
+ },
+ "gas" : "9999",
+ "out" : "0x",
+ "post" : {
+ "cd1722f3947def4cf144679da39c4c32bdc35681" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ },
+ "pre" : {
+ "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+ "balance" : "1000000000000000000",
+ "code" : "0x33ff",
+ "nonce" : "0",
+ "storage" : {
+ }
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/tests/helper/common.go b/tests/helper/common.go
new file mode 100644
index 0000000000000000000000000000000000000000..6a071968d2fa9d481517932e2d5b513c0f3af691
--- /dev/null
+++ b/tests/helper/common.go
@@ -0,0 +1,11 @@
+package helper
+
+import "github.com/ethereum/go-ethereum/ethutil"
+
+func FromHex(h string) []byte {
+ if ethutil.IsHex(h) {
+ h = h[2:]
+ }
+
+ return ethutil.Hex2Bytes(h)
+}
diff --git a/tests/helper/init.go b/tests/helper/init.go
new file mode 100644
index 0000000000000000000000000000000000000000..896ed5fe05e86489ec7c7e22ccb97c18426208bd
--- /dev/null
+++ b/tests/helper/init.go
@@ -0,0 +1,19 @@
+package helper
+
+import (
+ "log"
+ "os"
+
+ "github.com/ethereum/go-ethereum/ethlog"
+ "github.com/ethereum/go-ethereum/ethutil"
+)
+
+var Logger ethlog.LogSystem
+var Log = ethlog.NewLogger("TEST")
+
+func init() {
+ Logger = ethlog.NewStdLogSystem(os.Stdout, log.LstdFlags, ethlog.InfoLevel)
+ ethlog.AddLogSystem(Logger)
+
+ ethutil.ReadConfig(".ethtest", "/tmp/ethtest", "")
+}
diff --git a/tests/helper/readers.go b/tests/helper/readers.go
new file mode 100644
index 0000000000000000000000000000000000000000..03313aedaeb619f75690ae9b08b610c545ca6b36
--- /dev/null
+++ b/tests/helper/readers.go
@@ -0,0 +1,42 @@
+package helper
+
+import (
+ "encoding/json"
+ "io"
+ "io/ioutil"
+ "net/http"
+ "os"
+ "testing"
+)
+
+func readJSON(t *testing.T, reader io.Reader, value interface{}) {
+ data, err := ioutil.ReadAll(reader)
+ err = json.Unmarshal(data, &value)
+ if err != nil {
+ t.Error(err)
+ }
+}
+
+func CreateHttpTests(t *testing.T, uri string, value interface{}) {
+ resp, err := http.Get(uri)
+ if err != nil {
+ t.Error(err)
+
+ return
+ }
+ defer resp.Body.Close()
+
+ readJSON(t, resp.Body, value)
+}
+
+func CreateFileTests(t *testing.T, fn string, value interface{}) {
+ file, err := os.Open(fn)
+ if err != nil {
+ t.Error(err)
+
+ return
+ }
+ defer file.Close()
+
+ readJSON(t, file, value)
+}
diff --git a/tests/helper/trie.go b/tests/helper/trie.go
new file mode 100644
index 0000000000000000000000000000000000000000..119bac7134e3655c82da304faa71920c6f3cb5a4
--- /dev/null
+++ b/tests/helper/trie.go
@@ -0,0 +1,31 @@
+package helper
+
+import "github.com/ethereum/go-ethereum/ethtrie"
+
+type MemDatabase struct {
+ db map[string][]byte
+}
+
+func NewMemDatabase() (*MemDatabase, error) {
+ db := &MemDatabase{db: make(map[string][]byte)}
+ return db, nil
+}
+func (db *MemDatabase) Put(key []byte, value []byte) {
+ db.db[string(key)] = value
+}
+func (db *MemDatabase) Get(key []byte) ([]byte, error) {
+ return db.db[string(key)], nil
+}
+func (db *MemDatabase) Delete(key []byte) error {
+ delete(db.db, string(key))
+ return nil
+}
+func (db *MemDatabase) Print() {}
+func (db *MemDatabase) Close() {}
+func (db *MemDatabase) LastKnownTD() []byte { return nil }
+
+func NewTrie() *ethtrie.Trie {
+ db, _ := NewMemDatabase()
+
+ return ethtrie.New(db, "")
+}
diff --git a/tests/helper/vm.go b/tests/helper/vm.go
new file mode 100644
index 0000000000000000000000000000000000000000..5660caf64c5ebef85bf51a8d4ab3ed043168c202
--- /dev/null
+++ b/tests/helper/vm.go
@@ -0,0 +1,67 @@
+package helper
+
+import (
+ "math/big"
+
+ "github.com/ethereum/go-ethereum/ethstate"
+ "github.com/ethereum/go-ethereum/ethutil"
+ "github.com/ethereum/go-ethereum/vm"
+)
+
+type Env struct {
+ state *ethstate.State
+
+ origin []byte
+ parent []byte
+ coinbase []byte
+
+ number *big.Int
+ time int64
+ difficulty *big.Int
+ gasLimit *big.Int
+}
+
+func NewEnv(state *ethstate.State) *Env {
+ return &Env{
+ state: state,
+ }
+}
+
+func NewEnvFromMap(state *ethstate.State, envValues map[string]string, exeValues map[string]string) *Env {
+ env := NewEnv(state)
+
+ env.origin = ethutil.Hex2Bytes(exeValues["caller"])
+ env.parent = ethutil.Hex2Bytes(envValues["previousHash"])
+ env.coinbase = ethutil.Hex2Bytes(envValues["currentCoinbase"])
+ env.number = ethutil.Big(envValues["currentNumber"])
+ env.time = ethutil.Big(envValues["currentTimestamp"]).Int64()
+ env.difficulty = ethutil.Big(envValues["currentDifficulty"])
+ env.gasLimit = ethutil.Big(envValues["currentGasLimit"])
+
+ return env
+}
+
+func (self *Env) Origin() []byte { return self.origin }
+func (self *Env) BlockNumber() *big.Int { return self.number }
+func (self *Env) PrevHash() []byte { return self.parent }
+func (self *Env) Coinbase() []byte { return self.coinbase }
+func (self *Env) Time() int64 { return self.time }
+func (self *Env) Difficulty() *big.Int { return self.difficulty }
+func (self *Env) BlockHash() []byte { return nil }
+func (self *Env) State() *ethstate.State { return self.state }
+func (self *Env) GasLimit() *big.Int { return self.gasLimit }
+func (self *Env) Transfer(from, to vm.Account, amount *big.Int) error {
+ return vm.Transfer(from, to, amount)
+}
+
+func RunVm(state *ethstate.State, env, exec map[string]string) ([]byte, *big.Int, error) {
+ address := FromHex(exec["address"])
+ caller := state.GetOrNewStateObject(FromHex(exec["caller"]))
+
+ evm := vm.New(NewEnvFromMap(state, env, exec), vm.DebugVmTy)
+ execution := vm.NewExecution(evm, address, FromHex(exec["data"]), ethutil.Big(exec["gas"]), ethutil.Big(exec["gasPrice"]), ethutil.Big(exec["value"]))
+ execution.SkipTransfer = true
+ ret, err := execution.Exec(address, caller)
+
+ return ret, execution.Gas, err
+}
diff --git a/tests/vm/.ethtest b/tests/vm/.ethtest
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/tests/vm/gh_test.go b/tests/vm/gh_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..0d3c2f93d22581504f4223d01211694f3bfff8d1
--- /dev/null
+++ b/tests/vm/gh_test.go
@@ -0,0 +1,130 @@
+package vm
+
+import (
+ "bytes"
+ "testing"
+
+ "github.com/ethereum/go-ethereum/ethstate"
+ "github.com/ethereum/go-ethereum/ethutil"
+ "github.com/ethereum/go-ethereum/tests/helper"
+)
+
+type Account struct {
+ Balance string
+ Code string
+ Nonce string
+ Storage map[string]string
+}
+
+func StateObjectFromAccount(addr string, account Account) *ethstate.StateObject {
+ obj := ethstate.NewStateObject(ethutil.Hex2Bytes(addr))
+ obj.SetBalance(ethutil.Big(account.Balance))
+
+ if ethutil.IsHex(account.Code) {
+ account.Code = account.Code[2:]
+ }
+ obj.Code = ethutil.Hex2Bytes(account.Code)
+ obj.Nonce = ethutil.Big(account.Nonce).Uint64()
+
+ return obj
+}
+
+type VmTest struct {
+ Callcreates interface{}
+ Env map[string]string
+ Exec map[string]string
+ Gas string
+ Out string
+ Post map[string]Account
+ Pre map[string]Account
+}
+
+func RunVmTest(p string, t *testing.T) {
+ tests := make(map[string]VmTest)
+ helper.CreateFileTests(t, p, &tests)
+
+ for name, test := range tests {
+ state := ethstate.New(helper.NewTrie())
+ for addr, account := range test.Pre {
+ obj := StateObjectFromAccount(addr, account)
+ state.SetStateObject(obj)
+ }
+
+ ret, gas, err := helper.RunVm(state, test.Env, test.Exec)
+ // When an error is returned it doesn't always mean the tests fails.
+ // Have to come up with some conditional failing mechanism.
+ if err != nil {
+ helper.Log.Infoln(err)
+ }
+
+ rexp := helper.FromHex(test.Out)
+ if bytes.Compare(rexp, ret) != 0 {
+ t.Errorf("%s's return failed. Expected %x, got %x\n", name, rexp, ret)
+ }
+
+ gexp := ethutil.Big(test.Gas)
+ if gexp.Cmp(gas) != 0 {
+ t.Errorf("%s's gas failed. Expected %v, got %v\n", name, gexp, gas)
+ }
+
+ for addr, account := range test.Post {
+ obj := state.GetStateObject(helper.FromHex(addr))
+ for addr, value := range account.Storage {
+ v := obj.GetState(helper.FromHex(addr)).Bytes()
+ vexp := helper.FromHex(value)
+
+ if bytes.Compare(v, vexp) != 0 {
+ t.Errorf("%s's : (%x: %s) storage failed. Expected %x, got %x (%v %v)\n", name, obj.Address()[0:4], addr, vexp, v, ethutil.BigD(vexp), ethutil.BigD(v))
+ }
+ }
+ }
+ }
+}
+
+// I've created a new function for each tests so it's easier to identify where the problem lies if any of them fail.
+func TestVMArithmetic(t *testing.T) {
+ //helper.Logger.SetLogLevel(5)
+ const fn = "../files/vmtests/vmArithmeticTest.json"
+ RunVmTest(fn, t)
+}
+
+func TestVMSystemOperation(t *testing.T) {
+ //helper.Logger.SetLogLevel(5)
+ const fn = "../files/vmtests/vmSystemOperationsTest.json"
+ RunVmTest(fn, t)
+}
+
+func TestBitwiseLogicOperation(t *testing.T) {
+ const fn = "../files/vmtests/vmBitwiseLogicOperationTest.json"
+ RunVmTest(fn, t)
+}
+
+func TestBlockInfo(t *testing.T) {
+ const fn = "../files/vmtests/vmBlockInfoTest.json"
+ RunVmTest(fn, t)
+}
+
+func TestEnvironmentalInfo(t *testing.T) {
+ const fn = "../files/vmtests/vmEnvironmentalInfoTest.json"
+ RunVmTest(fn, t)
+}
+
+func TestFlowOperation(t *testing.T) {
+ const fn = "../files/vmtests/vmIOandFlowOperationsTest.json"
+ RunVmTest(fn, t)
+}
+
+func TestPushDupSwap(t *testing.T) {
+ const fn = "../files/vmtests/vmPushDupSwapTest.json"
+ RunVmTest(fn, t)
+}
+
+func TestVMSha3(t *testing.T) {
+ const fn = "../files/vmtests/vmSha3Test.json"
+ RunVmTest(fn, t)
+}
+
+func TestVm(t *testing.T) {
+ const fn = "../files/vmtests/vmtests.json"
+ RunVmTest(fn, t)
+}
diff --git a/types/ethereum.go b/types/ethereum.go
new file mode 100644
index 0000000000000000000000000000000000000000..ab1254f4c2bef8c6f41f1042ec2fbd3381d1bea8
--- /dev/null
+++ b/types/ethereum.go
@@ -0,0 +1 @@
+package types
diff --git a/ui/filter.go b/ui/filter.go
new file mode 100644
index 0000000000000000000000000000000000000000..ad29abbc55588c3fde7f950095abe0450558a04a
--- /dev/null
+++ b/ui/filter.go
@@ -0,0 +1,75 @@
+package ui
+
+import (
+ "github.com/ethereum/go-ethereum/ethchain"
+ "github.com/ethereum/go-ethereum/ethutil"
+)
+
+func NewFilterFromMap(object map[string]interface{}, eth ethchain.EthManager) *ethchain.Filter {
+ filter := ethchain.NewFilter(eth)
+
+ if object["earliest"] != nil {
+ val := ethutil.NewValue(object["earliest"])
+ filter.SetEarliestBlock(val.Int())
+ }
+
+ if object["latest"] != nil {
+ val := ethutil.NewValue(object["latest"])
+ filter.SetLatestBlock(val.Int())
+ }
+
+ if object["to"] != nil {
+ val := ethutil.NewValue(object["to"])
+ filter.AddTo(ethutil.Hex2Bytes(val.Str()))
+ }
+
+ if object["from"] != nil {
+ val := ethutil.NewValue(object["from"])
+ filter.AddFrom(ethutil.Hex2Bytes(val.Str()))
+ }
+
+ if object["max"] != nil {
+ val := ethutil.NewValue(object["max"])
+ filter.SetMax(int(val.Uint()))
+ }
+
+ if object["skip"] != nil {
+ val := ethutil.NewValue(object["skip"])
+ filter.SetSkip(int(val.Uint()))
+ }
+
+ if object["altered"] != nil {
+ filter.Altered = makeAltered(object["altered"])
+ }
+
+ return filter
+}
+
+// Conversion methodn
+func mapToAccountChange(m map[string]interface{}) (d ethchain.AccountChange) {
+ if str, ok := m["id"].(string); ok {
+ d.Address = ethutil.Hex2Bytes(str)
+ }
+
+ if str, ok := m["at"].(string); ok {
+ d.StateAddress = ethutil.Hex2Bytes(str)
+ }
+
+ return
+}
+
+// data can come in in the following formats:
+// ["aabbccdd", {id: "ccddee", at: "11223344"}], "aabbcc", {id: "ccddee", at: "1122"}
+func makeAltered(v interface{}) (d []ethchain.AccountChange) {
+ if str, ok := v.(string); ok {
+ d = append(d, ethchain.AccountChange{ethutil.Hex2Bytes(str), nil})
+ } else if obj, ok := v.(map[string]interface{}); ok {
+ d = append(d, mapToAccountChange(obj))
+ } else if slice, ok := v.([]interface{}); ok {
+ for _, item := range slice {
+ d = append(d, makeAltered(item)...)
+ }
+ }
+
+ return
+}
diff --git a/ui/qt/filter.go b/ui/qt/filter.go
new file mode 100644
index 0000000000000000000000000000000000000000..1fd99e78eba1e02b0d8393f0b86be3a7ebb2c503
--- /dev/null
+++ b/ui/qt/filter.go
@@ -0,0 +1,38 @@
+package qt
+
+import (
+ "fmt"
+
+ "github.com/ethereum/go-ethereum/ethchain"
+ "github.com/ethereum/go-ethereum/ui"
+ "gopkg.in/qml.v1"
+)
+
+func NewFilterFromMap(object map[string]interface{}, eth ethchain.EthManager) *ethchain.Filter {
+ filter := ui.NewFilterFromMap(object, eth)
+
+ if object["altered"] != nil {
+ filter.Altered = makeAltered(object["altered"])
+ }
+
+ return filter
+}
+
+func makeAltered(v interface{}) (d []ethchain.AccountChange) {
+ if qList, ok := v.(*qml.List); ok {
+ var s []interface{}
+ qList.Convert(&s)
+
+ fmt.Println(s)
+
+ d = makeAltered(s)
+ } else if qMap, ok := v.(*qml.Map); ok {
+ var m map[string]interface{}
+ qMap.Convert(&m)
+ fmt.Println(m)
+
+ d = makeAltered(m)
+ }
+
+ return
+}
diff --git a/utils/cmd.go b/utils/cmd.go
index 32aebc91eae7ec307a8ed66c5196649b78e71b3a..76faa5dac9755cd83a319565fd6f8bdc3b1ded28 100644
--- a/utils/cmd.go
+++ b/utils/cmd.go
@@ -13,15 +13,15 @@ import (
"time"
"bitbucket.org/kardianos/osext"
- "github.com/ethereum/eth-go"
- "github.com/ethereum/eth-go/ethcrypto"
- "github.com/ethereum/eth-go/ethdb"
- "github.com/ethereum/eth-go/ethlog"
- "github.com/ethereum/eth-go/ethminer"
- "github.com/ethereum/eth-go/ethpipe"
- "github.com/ethereum/eth-go/ethutil"
- "github.com/ethereum/eth-go/ethwire"
- "github.com/ethereum/eth-go/rpc"
+ "github.com/ethereum/go-ethereum"
+ "github.com/ethereum/go-ethereum/ethcrypto"
+ "github.com/ethereum/go-ethereum/ethdb"
+ "github.com/ethereum/go-ethereum/ethlog"
+ "github.com/ethereum/go-ethereum/ethminer"
+ "github.com/ethereum/go-ethereum/ethpipe"
+ "github.com/ethereum/go-ethereum/ethutil"
+ "github.com/ethereum/go-ethereum/ethwire"
+ "github.com/ethereum/go-ethereum/rpc"
)
var logger = ethlog.NewLogger("CLI")
diff --git a/utils/vm_env.go b/utils/vm_env.go
index 21341ab04c080002b9b949b7f8b62a4a9a144e56..1946b6fac8a704df80879e076c64500d7000d2c3 100644
--- a/utils/vm_env.go
+++ b/utils/vm_env.go
@@ -3,9 +3,9 @@ package utils
import (
"math/big"
- "github.com/ethereum/eth-go/ethchain"
- "github.com/ethereum/eth-go/ethstate"
- "github.com/ethereum/eth-go/vm"
+ "github.com/ethereum/go-ethereum/ethchain"
+ "github.com/ethereum/go-ethereum/ethstate"
+ "github.com/ethereum/go-ethereum/vm"
)
type VMEnv struct {
diff --git a/utils/websockets.go b/utils/websockets.go
index e89331a98d6edac9a98efff24fbae9395f44c802..7bda805acd3c5548f90ce77dc74c2341631a2fed 100644
--- a/utils/websockets.go
+++ b/utils/websockets.go
@@ -1,10 +1,10 @@
package utils
import (
- "github.com/ethereum/eth-go"
- "github.com/ethereum/eth-go/ethpipe"
- "github.com/ethereum/eth-go/ethutil"
- "github.com/ethereum/eth-go/websocket"
+ "github.com/ethereum/go-ethereum"
+ "github.com/ethereum/go-ethereum/ethpipe"
+ "github.com/ethereum/go-ethereum/ethutil"
+ "github.com/ethereum/go-ethereum/websocket"
)
func args(v ...interface{}) []interface{} {
diff --git a/vm/.ethtest b/vm/.ethtest
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/vm/address.go b/vm/address.go
new file mode 100644
index 0000000000000000000000000000000000000000..c4aa1eb7c3d1a750a2de513d9857c9477fd47412
--- /dev/null
+++ b/vm/address.go
@@ -0,0 +1,42 @@
+package vm
+
+import (
+ "math/big"
+
+ "github.com/ethereum/go-ethereum/ethcrypto"
+ "github.com/ethereum/go-ethereum/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},
+}
+
+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)
+}
diff --git a/vm/asm.go b/vm/asm.go
new file mode 100644
index 0000000000000000000000000000000000000000..a94f01d3d293d2011cdcdd8579507e416e1f3457
--- /dev/null
+++ b/vm/asm.go
@@ -0,0 +1,45 @@
+package vm
+
+import (
+ "fmt"
+ "math/big"
+
+ "github.com/ethereum/go-ethereum/ethutil"
+)
+
+func Disassemble(script []byte) (asm []string) {
+ pc := new(big.Int)
+ for {
+ if pc.Cmp(big.NewInt(int64(len(script)))) >= 0 {
+ return
+ }
+
+ // Get the memory location of pc
+ val := script[pc.Int64()]
+ // Get the opcode (it must be an opcode!)
+ op := OpCode(val)
+
+ asm = append(asm, fmt.Sprintf("%v", op))
+
+ switch op {
+ 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:
+ pc.Add(pc, ethutil.Big1)
+ a := int64(op) - int64(PUSH1) + 1
+ if int(pc.Int64()+a) > len(script) {
+ return nil
+ }
+
+ data := script[pc.Int64() : pc.Int64()+a]
+ if len(data) == 0 {
+ data = []byte{0}
+ }
+ asm = append(asm, fmt.Sprintf("0x%x", data))
+
+ pc.Add(pc, big.NewInt(a-1))
+ }
+
+ pc.Add(pc, ethutil.Big1)
+ }
+
+ return
+}
diff --git a/vm/closure.go b/vm/closure.go
new file mode 100644
index 0000000000000000000000000000000000000000..b556bc03d8765bf79153c498e89b4e2ff8c4dec9
--- /dev/null
+++ b/vm/closure.go
@@ -0,0 +1,140 @@
+package vm
+
+// TODO Re write VM to use values instead of big integers?
+
+import (
+ "math/big"
+
+ "github.com/ethereum/go-ethereum/ethstate"
+ "github.com/ethereum/go-ethereum/ethutil"
+)
+
+type ClosureRef interface {
+ ReturnGas(*big.Int, *big.Int)
+ Address() []byte
+ Object() *ethstate.StateObject
+ GetStorage(*big.Int) *ethutil.Value
+ SetStorage(*big.Int, *ethutil.Value)
+}
+
+// Basic inline closure object which implement the 'closure' interface
+type Closure struct {
+ caller ClosureRef
+ object *ethstate.StateObject
+ Code []byte
+ message *ethstate.Message
+ exe *Execution
+
+ Gas, UsedGas, Price *big.Int
+
+ Args []byte
+}
+
+// Create a new closure for the given data items
+func NewClosure(msg *ethstate.Message, caller ClosureRef, object *ethstate.StateObject, code []byte, gas, price *big.Int) *Closure {
+ c := &Closure{message: msg, caller: caller, object: object, Code: code, Args: nil}
+
+ // Gas should be a pointer so it can safely be reduced through the run
+ // This pointer will be off the state transition
+ c.Gas = gas //new(big.Int).Set(gas)
+ // In most cases price and value are pointers to transaction objects
+ // and we don't want the transaction's values to change.
+ c.Price = new(big.Int).Set(price)
+ c.UsedGas = new(big.Int)
+
+ return c
+}
+
+// Retuns the x element in data slice
+func (c *Closure) GetStorage(x *big.Int) *ethutil.Value {
+ m := c.object.GetStorage(x)
+ if m == nil {
+ return ethutil.EmptyValue()
+ }
+
+ return m
+}
+
+func (c *Closure) Get(x *big.Int) *ethutil.Value {
+ return c.Gets(x, big.NewInt(1))
+}
+
+func (c *Closure) GetOp(x int) OpCode {
+ return OpCode(c.GetByte(x))
+}
+
+func (c *Closure) GetByte(x int) byte {
+ if x < len(c.Code) {
+ return c.Code[x]
+ }
+
+ return 0
+}
+
+func (c *Closure) GetBytes(x, y int) []byte {
+ if x >= len(c.Code) || y >= len(c.Code) {
+ return nil
+ }
+
+ return c.Code[x : x+y]
+}
+
+func (c *Closure) Gets(x, y *big.Int) *ethutil.Value {
+ if x.Int64() >= int64(len(c.Code)) || y.Int64() >= int64(len(c.Code)) {
+ return ethutil.NewValue(0)
+ }
+
+ partial := c.Code[x.Int64() : x.Int64()+y.Int64()]
+
+ return ethutil.NewValue(partial)
+}
+
+func (c *Closure) SetStorage(x *big.Int, val *ethutil.Value) {
+ c.object.SetStorage(x, val)
+}
+
+func (c *Closure) Address() []byte {
+ return c.object.Address()
+}
+
+func (c *Closure) Call(vm VirtualMachine, args []byte) ([]byte, *big.Int, error) {
+ c.Args = args
+
+ ret, err := vm.RunClosure(c)
+
+ return ret, c.UsedGas, err
+}
+
+func (c *Closure) Return(ret []byte) []byte {
+ // Return the remaining gas to the caller
+ c.caller.ReturnGas(c.Gas, c.Price)
+
+ return ret
+}
+
+func (c *Closure) UseGas(gas *big.Int) bool {
+ if c.Gas.Cmp(gas) < 0 {
+ return false
+ }
+
+ // Sub the amount of gas from the remaining
+ c.Gas.Sub(c.Gas, gas)
+ c.UsedGas.Add(c.UsedGas, gas)
+
+ return true
+}
+
+// Implement the caller interface
+func (c *Closure) ReturnGas(gas, price *big.Int) {
+ // Return the gas to the closure
+ c.Gas.Add(c.Gas, gas)
+ c.UsedGas.Sub(c.UsedGas, gas)
+}
+
+func (c *Closure) Object() *ethstate.StateObject {
+ return c.object
+}
+
+func (c *Closure) Caller() ClosureRef {
+ return c.caller
+}
diff --git a/vm/common.go b/vm/common.go
new file mode 100644
index 0000000000000000000000000000000000000000..3b0d735babb09af8151ddd48a7f2851f1cb85791
--- /dev/null
+++ b/vm/common.go
@@ -0,0 +1,66 @@
+package vm
+
+import (
+ "math/big"
+
+ "github.com/ethereum/go-ethereum/ethlog"
+ "github.com/ethereum/go-ethereum/ethutil"
+)
+
+var vmlogger = ethlog.NewLogger("VM")
+
+type Type int
+
+const (
+ StandardVmTy Type = iota
+ DebugVmTy
+
+ MaxVmTy
+)
+
+var (
+ GasStep = big.NewInt(1)
+ GasSha = big.NewInt(20)
+ GasSLoad = big.NewInt(20)
+ GasSStore = big.NewInt(100)
+ GasBalance = big.NewInt(20)
+ GasCreate = big.NewInt(100)
+ GasCall = big.NewInt(20)
+ GasMemory = big.NewInt(1)
+ GasData = big.NewInt(5)
+ GasTx = big.NewInt(500)
+
+ Pow256 = ethutil.BigPow(2, 256)
+
+ LogTyPretty byte = 0x1
+ LogTyDiff byte = 0x2
+
+ U256 = ethutil.U256
+ S256 = ethutil.S256
+)
+
+const MaxCallDepth = 1025
+
+func calcMemSize(off, l *big.Int) *big.Int {
+ if l.Cmp(ethutil.Big0) == 0 {
+ return ethutil.Big0
+ }
+
+ return new(big.Int).Add(off, l)
+}
+
+// Simple helper
+func u256(n int64) *big.Int {
+ return big.NewInt(n)
+}
+
+// Mainly used for print variables and passing to Print*
+func toValue(val *big.Int) interface{} {
+ // Let's assume a string on right padded zero's
+ b := val.Bytes()
+ if b[0] != 0 && b[len(b)-1] == 0x0 && b[len(b)-2] == 0x0 {
+ return string(b)
+ }
+
+ return val
+}
diff --git a/vm/debugger.go b/vm/debugger.go
new file mode 100644
index 0000000000000000000000000000000000000000..b0d0e545d56a9885cb3774ac10b1f7f9c6b39349
--- /dev/null
+++ b/vm/debugger.go
@@ -0,0 +1,10 @@
+package vm
+
+import "github.com/ethereum/go-ethereum/ethstate"
+
+type Debugger interface {
+ BreakHook(step int, op OpCode, mem *Memory, stack *Stack, object *ethstate.StateObject) bool
+ StepHook(step int, op OpCode, mem *Memory, stack *Stack, object *ethstate.StateObject) bool
+ BreakPoints() []int64
+ SetCode(byteCode []byte)
+}
diff --git a/vm/environment.go b/vm/environment.go
new file mode 100644
index 0000000000000000000000000000000000000000..af67c4179a9a87a28f0ce3b9ed53ca29fcce357d
--- /dev/null
+++ b/vm/environment.go
@@ -0,0 +1,46 @@
+package vm
+
+import (
+ "errors"
+ "math/big"
+
+ "github.com/ethereum/go-ethereum/ethstate"
+ "github.com/ethereum/go-ethereum/ethutil"
+)
+
+type Environment interface {
+ State() *ethstate.State
+
+ Origin() []byte
+ BlockNumber() *big.Int
+ PrevHash() []byte
+ Coinbase() []byte
+ Time() int64
+ Difficulty() *big.Int
+ BlockHash() []byte
+ GasLimit() *big.Int
+ Transfer(from, to Account, amount *big.Int) error
+}
+
+type Object interface {
+ GetStorage(key *big.Int) *ethutil.Value
+ SetStorage(key *big.Int, value *ethutil.Value)
+}
+
+type Account interface {
+ SubBalance(amount *big.Int)
+ AddBalance(amount *big.Int)
+ Balance() *big.Int
+}
+
+// generic transfer method
+func Transfer(from, to Account, amount *big.Int) error {
+ if from.Balance().Cmp(amount) < 0 {
+ return errors.New("Insufficient balance in account")
+ }
+
+ from.SubBalance(amount)
+ to.AddBalance(amount)
+
+ return nil
+}
diff --git a/vm/errors.go b/vm/errors.go
new file mode 100644
index 0000000000000000000000000000000000000000..ab011bd624fb2082885158195cbd784a97a0dd11
--- /dev/null
+++ b/vm/errors.go
@@ -0,0 +1,51 @@
+package vm
+
+import (
+ "fmt"
+ "math/big"
+)
+
+type OutOfGasError struct {
+ req, has *big.Int
+}
+
+func OOG(req, has *big.Int) OutOfGasError {
+ return OutOfGasError{req, has}
+}
+
+func (self OutOfGasError) Error() string {
+ return fmt.Sprintf("out of gas! require %v, have %v", self.req, self.has)
+}
+
+func IsOOGErr(err error) bool {
+ _, ok := err.(OutOfGasError)
+ return ok
+}
+
+type StackError struct {
+ req, has int
+}
+
+func StackErr(req, has int) StackError {
+ return StackError{req, has}
+}
+
+func (self StackError) Error() string {
+ return fmt.Sprintf("stack error! require %v, have %v", self.req, self.has)
+}
+
+func IsStack(err error) bool {
+ _, ok := err.(StackError)
+ return ok
+}
+
+type DepthError struct{}
+
+func (self DepthError) Error() string {
+ return fmt.Sprintf("Max call depth exceeded (%d)", MaxCallDepth)
+}
+
+func IsDepthErr(err error) bool {
+ _, ok := err.(DepthError)
+ return ok
+}
diff --git a/vm/execution.go b/vm/execution.go
new file mode 100644
index 0000000000000000000000000000000000000000..8da0469dea5ef0257db0163c64668ce2d8e21866
--- /dev/null
+++ b/vm/execution.go
@@ -0,0 +1,93 @@
+package vm
+
+import (
+ "fmt"
+ "math/big"
+
+ "github.com/ethereum/go-ethereum/ethstate"
+ "github.com/ethereum/go-ethereum/ethutil"
+)
+
+type Execution struct {
+ vm VirtualMachine
+ address, input []byte
+ Gas, price, value *big.Int
+ object *ethstate.StateObject
+ SkipTransfer bool
+}
+
+func NewExecution(vm VirtualMachine, 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 *Execution) Addr() []byte {
+ return self.address
+}
+
+func (self *Execution) Exec(codeAddr []byte, caller ClosureRef) ([]byte, error) {
+ // Retrieve the executing code
+ code := self.vm.Env().State().GetCode(codeAddr)
+
+ return self.exec(code, codeAddr, caller)
+}
+
+func (self *Execution) exec(code, caddr []byte, caller ClosureRef) (ret []byte, err error) {
+ env := self.vm.Env()
+
+ snapshot := env.State().Copy()
+ defer func() {
+ if IsDepthErr(err) || IsOOGErr(err) {
+ env.State().Set(snapshot)
+ }
+ }()
+
+ msg := env.State().Manifest().AddMessage(ðstate.Message{
+ To: self.address, From: caller.Address(),
+ Input: self.input,
+ Origin: env.Origin(),
+ Block: env.BlockHash(), Timestamp: env.Time(), Coinbase: env.Coinbase(), Number: env.BlockNumber(),
+ Value: self.value,
+ })
+
+ from, to := caller.Object(), 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)
+
+ err = fmt.Errorf("Insufficient funds to transfer value. Req %v, has %v", self.value, from.Balance)
+ } else {
+ self.object = to
+ // Pre-compiled contracts (address.go) 1, 2 & 3.
+ naddr := ethutil.BigD(caddr).Uint64()
+ if p := Precompiled[naddr]; p != nil {
+ if self.Gas.Cmp(p.Gas) >= 0 {
+ ret = p.Call(self.input)
+ self.vm.Printf("NATIVE_FUNC(%x) => %x", naddr, ret)
+ }
+ } else {
+ // Create a new callable closure
+ c := NewClosure(msg, caller, to, code, self.Gas, self.price)
+ c.exe = self
+
+ if self.vm.Depth() == MaxCallDepth {
+ c.UseGas(self.Gas)
+
+ return c.Return(nil), DepthError{}
+ }
+
+ // Executer the closure and get the return value (if any)
+ ret, _, err = c.Call(self.vm, self.input)
+ msg.Output = ret
+ }
+ }
+
+ return
+}
+
+func (self *Execution) Create(caller ClosureRef) (ret []byte, err error) {
+ return self.exec(self.input, nil, caller)
+}
diff --git a/vm/stack.go b/vm/stack.go
new file mode 100644
index 0000000000000000000000000000000000000000..55fdb6d1598fbc1dcd9fd136c1ea655a69e7e18d
--- /dev/null
+++ b/vm/stack.go
@@ -0,0 +1,162 @@
+package vm
+
+import (
+ "fmt"
+ "math"
+ "math/big"
+)
+
+type OpType int
+
+const (
+ tNorm = iota
+ tData
+ tExtro
+ tCrypto
+)
+
+type TxCallback func(opType OpType) bool
+
+// Simple push/pop stack mechanism
+type Stack struct {
+ data []*big.Int
+}
+
+func NewStack() *Stack {
+ return &Stack{}
+}
+
+func (st *Stack) Data() []*big.Int {
+ return st.data
+}
+
+func (st *Stack) Len() int {
+ return len(st.data)
+}
+
+func (st *Stack) Pop() *big.Int {
+ str := st.data[len(st.data)-1]
+
+ copy(st.data[:len(st.data)-1], st.data[:len(st.data)-1])
+ st.data = st.data[:len(st.data)-1]
+
+ return str
+}
+
+func (st *Stack) Popn() (*big.Int, *big.Int) {
+ ints := st.data[len(st.data)-2:]
+
+ copy(st.data[:len(st.data)-2], st.data[:len(st.data)-2])
+ st.data = st.data[:len(st.data)-2]
+
+ return ints[0], ints[1]
+}
+
+func (st *Stack) Peek() *big.Int {
+ str := st.data[len(st.data)-1]
+
+ return str
+}
+
+func (st *Stack) Peekn() (*big.Int, *big.Int) {
+ ints := st.data[len(st.data)-2:]
+
+ return ints[0], ints[1]
+}
+
+func (st *Stack) Swapn(n int) (*big.Int, *big.Int) {
+ st.data[len(st.data)-n], st.data[len(st.data)-1] = st.data[len(st.data)-1], st.data[len(st.data)-n]
+
+ return st.data[len(st.data)-n], st.data[len(st.data)-1]
+}
+
+func (st *Stack) Dupn(n int) *big.Int {
+ st.Push(st.data[len(st.data)-n])
+
+ return st.Peek()
+}
+
+func (st *Stack) Push(d *big.Int) {
+ st.data = append(st.data, new(big.Int).Set(d))
+}
+
+func (st *Stack) Get(amount *big.Int) []*big.Int {
+ // offset + size <= len(data)
+ length := big.NewInt(int64(len(st.data)))
+ if amount.Cmp(length) <= 0 {
+ start := new(big.Int).Sub(length, amount)
+ return st.data[start.Int64():length.Int64()]
+ }
+
+ return nil
+}
+
+func (st *Stack) Print() {
+ fmt.Println("### stack ###")
+ if len(st.data) > 0 {
+ for i, val := range st.data {
+ fmt.Printf("%-3d %v\n", i, val)
+ }
+ } else {
+ fmt.Println("-- empty --")
+ }
+ fmt.Println("#############")
+}
+
+type Memory struct {
+ store []byte
+}
+
+func (m *Memory) Set(offset, size int64, value []byte) {
+ totSize := offset + size
+ lenSize := int64(len(m.store) - 1)
+ if totSize > lenSize {
+ // Calculate the diff between the sizes
+ diff := totSize - lenSize
+ if diff > 0 {
+ // Create a new empty slice and append it
+ newSlice := make([]byte, diff-1)
+ // Resize slice
+ m.store = append(m.store, newSlice...)
+ }
+ }
+ copy(m.store[offset:offset+size], value)
+}
+
+func (m *Memory) Resize(size uint64) {
+ if uint64(m.Len()) < size {
+ m.store = append(m.store, make([]byte, size-uint64(m.Len()))...)
+ }
+}
+
+func (m *Memory) Get(offset, size int64) []byte {
+ if len(m.store) > int(offset) {
+ end := int(math.Min(float64(len(m.store)), float64(offset+size)))
+
+ return m.store[offset:end]
+ }
+
+ return nil
+}
+
+func (m *Memory) Len() int {
+ return len(m.store)
+}
+
+func (m *Memory) Data() []byte {
+ return m.store
+}
+
+func (m *Memory) Print() {
+ fmt.Printf("### mem %d bytes ###\n", len(m.store))
+ if len(m.store) > 0 {
+ addr := 0
+ for i := 0; i+32 <= len(m.store); i += 32 {
+ fmt.Printf("%03d: % x\n", addr, m.store[i:i+32])
+ addr++
+ }
+ } else {
+ fmt.Println("-- empty --")
+ }
+ fmt.Println("####################")
+}
diff --git a/vm/types.go b/vm/types.go
new file mode 100644
index 0000000000000000000000000000000000000000..6fb9a5c95fa27dd42c910421318f717bbf5a5b36
--- /dev/null
+++ b/vm/types.go
@@ -0,0 +1,312 @@
+package vm
+
+import (
+ "fmt"
+)
+
+type OpCode byte
+
+// Op codes
+const (
+ // 0x0 range - arithmetic ops
+ STOP = 0x00
+ ADD = 0x01
+ MUL = 0x02
+ SUB = 0x03
+ DIV = 0x04
+ SDIV = 0x05
+ MOD = 0x06
+ SMOD = 0x07
+ EXP = 0x08
+ NEG = 0x09
+ LT = 0x0a
+ GT = 0x0b
+ SLT = 0x0c
+ SGT = 0x0d
+ EQ = 0x0e
+ NOT = 0x0f
+
+ // 0x10 range - bit ops
+ AND = 0x10
+ OR = 0x11
+ XOR = 0x12
+ BYTE = 0x13
+ ADDMOD = 0x14
+ MULMOD = 0x15
+
+ // 0x20 range - crypto
+ SHA3 = 0x20
+
+ // 0x30 range - closure state
+ ADDRESS = 0x30
+ BALANCE = 0x31
+ ORIGIN = 0x32
+ CALLER = 0x33
+ CALLVALUE = 0x34
+ CALLDATALOAD = 0x35
+ CALLDATASIZE = 0x36
+ CALLDATACOPY = 0x37
+ CODESIZE = 0x38
+ CODECOPY = 0x39
+ GASPRICE = 0x3a
+ EXTCODESIZE = 0x3b
+ EXTCODECOPY = 0x3c
+
+ // 0x40 range - block operations
+ PREVHASH = 0x40
+ COINBASE = 0x41
+ TIMESTAMP = 0x42
+ NUMBER = 0x43
+ DIFFICULTY = 0x44
+ GASLIMIT = 0x45
+
+ // 0x50 range - 'storage' and execution
+ POP = 0x50
+ //DUP = 0x51
+ //SWAP = 0x52
+ MLOAD = 0x53
+ MSTORE = 0x54
+ MSTORE8 = 0x55
+ SLOAD = 0x56
+ SSTORE = 0x57
+ JUMP = 0x58
+ JUMPI = 0x59
+ PC = 0x5a
+ MSIZE = 0x5b
+ GAS = 0x5c
+ JUMPDEST = 0x5d
+
+ // 0x60 range
+ PUSH1 = 0x60
+ PUSH2 = 0x61
+ PUSH3 = 0x62
+ PUSH4 = 0x63
+ PUSH5 = 0x64
+ PUSH6 = 0x65
+ PUSH7 = 0x66
+ PUSH8 = 0x67
+ PUSH9 = 0x68
+ PUSH10 = 0x69
+ PUSH11 = 0x6a
+ PUSH12 = 0x6b
+ PUSH13 = 0x6c
+ PUSH14 = 0x6d
+ PUSH15 = 0x6e
+ PUSH16 = 0x6f
+ PUSH17 = 0x70
+ PUSH18 = 0x71
+ PUSH19 = 0x72
+ PUSH20 = 0x73
+ PUSH21 = 0x74
+ PUSH22 = 0x75
+ PUSH23 = 0x76
+ PUSH24 = 0x77
+ PUSH25 = 0x78
+ PUSH26 = 0x79
+ PUSH27 = 0x7a
+ PUSH28 = 0x7b
+ PUSH29 = 0x7c
+ PUSH30 = 0x7d
+ PUSH31 = 0x7e
+ PUSH32 = 0x7f
+
+ DUP1 = 0x80
+ DUP2 = 0x81
+ DUP3 = 0x82
+ DUP4 = 0x83
+ DUP5 = 0x84
+ DUP6 = 0x85
+ DUP7 = 0x86
+ DUP8 = 0x87
+ DUP9 = 0x88
+ DUP10 = 0x89
+ DUP11 = 0x8a
+ DUP12 = 0x8b
+ DUP13 = 0x8c
+ DUP14 = 0x8d
+ DUP15 = 0x8e
+ DUP16 = 0x8f
+
+ SWAP1 = 0x90
+ SWAP2 = 0x91
+ SWAP3 = 0x92
+ SWAP4 = 0x93
+ SWAP5 = 0x94
+ SWAP6 = 0x95
+ SWAP7 = 0x96
+ SWAP8 = 0x97
+ SWAP9 = 0x98
+ SWAP10 = 0x99
+ SWAP11 = 0x9a
+ SWAP12 = 0x9b
+ SWAP13 = 0x9c
+ SWAP14 = 0x9d
+ SWAP15 = 0x9e
+ SWAP16 = 0x9f
+
+ // 0xf0 range - closures
+ CREATE = 0xf0
+ CALL = 0xf1
+ RETURN = 0xf2
+ CALLCODE = 0xf3
+
+ // 0x70 range - other
+ SUICIDE = 0xff
+)
+
+// Since the opcodes aren't all in order we can't use a regular slice
+var opCodeToString = map[OpCode]string{
+ // 0x0 range - arithmetic ops
+ STOP: "STOP",
+ ADD: "ADD",
+ MUL: "MUL",
+ SUB: "SUB",
+ DIV: "DIV",
+ SDIV: "SDIV",
+ MOD: "MOD",
+ SMOD: "SMOD",
+ EXP: "EXP",
+ NEG: "NEG",
+ LT: "LT",
+ GT: "GT",
+ SLT: "SLT",
+ SGT: "SGT",
+ EQ: "EQ",
+ NOT: "NOT",
+
+ // 0x10 range - bit ops
+ AND: "AND",
+ OR: "OR",
+ XOR: "XOR",
+ BYTE: "BYTE",
+ ADDMOD: "ADDMOD",
+ MULMOD: "MULMOD",
+
+ // 0x20 range - crypto
+ SHA3: "SHA3",
+
+ // 0x30 range - closure state
+ ADDRESS: "ADDRESS",
+ BALANCE: "BALANCE",
+ ORIGIN: "ORIGIN",
+ CALLER: "CALLER",
+ CALLVALUE: "CALLVALUE",
+ CALLDATALOAD: "CALLDATALOAD",
+ CALLDATASIZE: "CALLDATASIZE",
+ CALLDATACOPY: "CALLDATACOPY",
+ CODESIZE: "CODESIZE",
+ CODECOPY: "CODECOPY",
+ GASPRICE: "TXGASPRICE",
+
+ // 0x40 range - block operations
+ PREVHASH: "PREVHASH",
+ COINBASE: "COINBASE",
+ TIMESTAMP: "TIMESTAMP",
+ NUMBER: "NUMBER",
+ DIFFICULTY: "DIFFICULTY",
+ GASLIMIT: "GASLIMIT",
+ EXTCODESIZE: "EXTCODESIZE",
+ EXTCODECOPY: "EXTCODECOPY",
+
+ // 0x50 range - 'storage' and execution
+ POP: "POP",
+ //DUP: "DUP",
+ //SWAP: "SWAP",
+ MLOAD: "MLOAD",
+ MSTORE: "MSTORE",
+ MSTORE8: "MSTORE8",
+ SLOAD: "SLOAD",
+ SSTORE: "SSTORE",
+ JUMP: "JUMP",
+ JUMPI: "JUMPI",
+ PC: "PC",
+ MSIZE: "MSIZE",
+ GAS: "GAS",
+ JUMPDEST: "JUMPDEST",
+
+ // 0x60 range - push
+ PUSH1: "PUSH1",
+ PUSH2: "PUSH2",
+ PUSH3: "PUSH3",
+ PUSH4: "PUSH4",
+ PUSH5: "PUSH5",
+ PUSH6: "PUSH6",
+ PUSH7: "PUSH7",
+ PUSH8: "PUSH8",
+ PUSH9: "PUSH9",
+ PUSH10: "PUSH10",
+ PUSH11: "PUSH11",
+ PUSH12: "PUSH12",
+ PUSH13: "PUSH13",
+ PUSH14: "PUSH14",
+ PUSH15: "PUSH15",
+ PUSH16: "PUSH16",
+ PUSH17: "PUSH17",
+ PUSH18: "PUSH18",
+ PUSH19: "PUSH19",
+ PUSH20: "PUSH20",
+ PUSH21: "PUSH21",
+ PUSH22: "PUSH22",
+ PUSH23: "PUSH23",
+ PUSH24: "PUSH24",
+ PUSH25: "PUSH25",
+ PUSH26: "PUSH26",
+ PUSH27: "PUSH27",
+ PUSH28: "PUSH28",
+ PUSH29: "PUSH29",
+ PUSH30: "PUSH30",
+ PUSH31: "PUSH31",
+ PUSH32: "PUSH32",
+
+ DUP1: "DUP1",
+ DUP2: "DUP2",
+ DUP3: "DUP3",
+ DUP4: "DUP4",
+ DUP5: "DUP5",
+ DUP6: "DUP6",
+ DUP7: "DUP7",
+ DUP8: "DUP8",
+ DUP9: "DUP9",
+ DUP10: "DUP10",
+ DUP11: "DUP11",
+ DUP12: "DUP12",
+ DUP13: "DUP13",
+ DUP14: "DUP14",
+ DUP15: "DUP15",
+ DUP16: "DUP16",
+
+ SWAP1: "SWAP1",
+ SWAP2: "SWAP2",
+ SWAP3: "SWAP3",
+ SWAP4: "SWAP4",
+ SWAP5: "SWAP5",
+ SWAP6: "SWAP6",
+ SWAP7: "SWAP7",
+ SWAP8: "SWAP8",
+ SWAP9: "SWAP9",
+ SWAP10: "SWAP10",
+ SWAP11: "SWAP11",
+ SWAP12: "SWAP12",
+ SWAP13: "SWAP13",
+ SWAP14: "SWAP14",
+ SWAP15: "SWAP15",
+ SWAP16: "SWAP16",
+
+ // 0xf0 range
+ CREATE: "CREATE",
+ CALL: "CALL",
+ RETURN: "RETURN",
+ CALLCODE: "CALLCODE",
+
+ // 0x70 range - other
+ SUICIDE: "SUICIDE",
+}
+
+func (o OpCode) String() string {
+ str := opCodeToString[o]
+ if len(str) == 0 {
+ return fmt.Sprintf("Missing opcode 0x%x", int(o))
+ }
+
+ return str
+}
diff --git a/vm/virtual_machine.go b/vm/virtual_machine.go
new file mode 100644
index 0000000000000000000000000000000000000000..cc8cd39a9ff4aa9dbc13dd43b323bd63ffb08de5
--- /dev/null
+++ b/vm/virtual_machine.go
@@ -0,0 +1,9 @@
+package vm
+
+type VirtualMachine interface {
+ Env() Environment
+ RunClosure(*Closure) ([]byte, error)
+ Depth() int
+ Printf(string, ...interface{}) VirtualMachine
+ Endl() VirtualMachine
+}
diff --git a/vm/vm.go b/vm/vm.go
new file mode 100644
index 0000000000000000000000000000000000000000..291f1cda4e1630f7ecae377f8cf9219a338c9f3b
--- /dev/null
+++ b/vm/vm.go
@@ -0,0 +1,720 @@
+package vm
+
+import (
+ "fmt"
+ "math/big"
+
+ "github.com/ethereum/go-ethereum/ethcrypto"
+ "github.com/ethereum/go-ethereum/ethutil"
+)
+
+// BIG FAT WARNING. THIS VM IS NOT YET IS USE!
+// I want to get all VM tests pass first before updating this VM
+
+type Vm struct {
+ env Environment
+ err error
+ depth int
+}
+
+func New(env Environment, typ Type) VirtualMachine {
+ switch typ {
+ case DebugVmTy:
+ return NewDebugVm(env)
+ default:
+ return &Vm{env: env}
+ }
+}
+
+func (self *Vm) RunClosure(closure *Closure) (ret []byte, err error) {
+ self.depth++
+
+ // Recover from any require exception
+ defer func() {
+ if r := recover(); r != nil {
+ ret = closure.Return(nil)
+ err = fmt.Errorf("%v", r)
+ }
+ }()
+
+ // Don't bother with the execution if there's no code.
+ if len(closure.Code) == 0 {
+ return closure.Return(nil), nil
+ }
+
+ var (
+ op OpCode
+
+ mem = &Memory{}
+ stack = NewStack()
+ pc = 0
+ step = 0
+ require = func(m int) {
+ if stack.Len() < m {
+ panic(fmt.Sprintf("%04v (%v) stack err size = %d, required = %d", pc, op, stack.Len(), m))
+ }
+ }
+ )
+
+ for {
+ // The base for all big integer arithmetic
+ base := new(big.Int)
+
+ step++
+ // Get the memory location of pc
+ op := closure.GetOp(pc)
+
+ gas := new(big.Int)
+ addStepGasUsage := func(amount *big.Int) {
+ gas.Add(gas, amount)
+ }
+
+ addStepGasUsage(GasStep)
+
+ var newMemSize *big.Int = ethutil.Big0
+ switch op {
+ case STOP:
+ gas.Set(ethutil.Big0)
+ case SUICIDE:
+ gas.Set(ethutil.Big0)
+ case SLOAD:
+ gas.Set(GasSLoad)
+ case SSTORE:
+ var mult *big.Int
+ y, x := stack.Peekn()
+ val := closure.GetStorage(x)
+ if val.BigInt().Cmp(ethutil.Big0) == 0 && len(y.Bytes()) > 0 {
+ mult = ethutil.Big2
+ } else if val.BigInt().Cmp(ethutil.Big0) != 0 && len(y.Bytes()) == 0 {
+ mult = ethutil.Big0
+ } else {
+ mult = ethutil.Big1
+ }
+ gas = new(big.Int).Mul(mult, GasSStore)
+ case BALANCE:
+ gas.Set(GasBalance)
+ case MSTORE:
+ require(2)
+ newMemSize = calcMemSize(stack.Peek(), u256(32))
+ case MLOAD:
+ require(1)
+
+ newMemSize = calcMemSize(stack.Peek(), u256(32))
+ case MSTORE8:
+ require(2)
+ newMemSize = calcMemSize(stack.Peek(), u256(1))
+ case RETURN:
+ require(2)
+
+ newMemSize = calcMemSize(stack.Peek(), stack.data[stack.Len()-2])
+ case SHA3:
+ require(2)
+
+ gas.Set(GasSha)
+
+ newMemSize = calcMemSize(stack.Peek(), stack.data[stack.Len()-2])
+ case CALLDATACOPY:
+ require(2)
+
+ newMemSize = calcMemSize(stack.Peek(), stack.data[stack.Len()-3])
+ case CODECOPY:
+ require(3)
+
+ newMemSize = calcMemSize(stack.Peek(), stack.data[stack.Len()-3])
+ case EXTCODECOPY:
+ require(4)
+
+ newMemSize = calcMemSize(stack.data[stack.Len()-2], stack.data[stack.Len()-4])
+ case CALL, CALLCODE:
+ 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:
+ require(3)
+ gas.Set(GasCreate)
+
+ newMemSize = calcMemSize(stack.data[stack.Len()-2], stack.data[stack.Len()-3])
+ }
+
+ 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)
+ }
+ }
+
+ if !closure.UseGas(gas) {
+ err := fmt.Errorf("Insufficient gas for %v. req %v has %v", op, gas, closure.Gas)
+
+ closure.UseGas(closure.Gas)
+
+ return closure.Return(nil), err
+ }
+
+ mem.Resize(newMemSize.Uint64())
+
+ switch op {
+ // 0x20 range
+ case ADD:
+ require(2)
+ x, y := stack.Popn()
+
+ base.Add(y, x)
+
+ U256(base)
+
+ // Pop result back on the stack
+ stack.Push(base)
+ case SUB:
+ require(2)
+ x, y := stack.Popn()
+
+ base.Sub(y, x)
+
+ U256(base)
+
+ // Pop result back on the stack
+ stack.Push(base)
+ case MUL:
+ require(2)
+ x, y := stack.Popn()
+
+ base.Mul(y, x)
+
+ U256(base)
+
+ // Pop result back on the stack
+ stack.Push(base)
+ case DIV:
+ require(2)
+ x, y := stack.Popn()
+
+ if x.Cmp(ethutil.Big0) != 0 {
+ base.Div(y, x)
+ }
+
+ U256(base)
+
+ // Pop result back on the stack
+ stack.Push(base)
+ case SDIV:
+ require(2)
+ y, x := S256(stack.Pop()), S256(stack.Pop())
+
+ if x.Cmp(ethutil.Big0) == 0 {
+ base.Set(ethutil.Big0)
+ } else {
+ n := new(big.Int)
+ if new(big.Int).Mul(y, x).Cmp(ethutil.Big0) < 0 {
+ n.SetInt64(-1)
+ } else {
+ n.SetInt64(1)
+ }
+
+ base.Div(y.Abs(y), x.Mul(x.Abs(x), n))
+
+ U256(base)
+ }
+
+ stack.Push(base)
+ case MOD:
+ require(2)
+ x, y := stack.Popn()
+
+ base.Mod(y, x)
+
+ U256(base)
+
+ stack.Push(base)
+ case SMOD:
+ require(2)
+ y, x := S256(stack.Pop()), S256(stack.Pop())
+
+ if x.Cmp(ethutil.Big0) == 0 {
+ base.Set(ethutil.Big0)
+ } else {
+ n := new(big.Int)
+ if y.Cmp(ethutil.Big0) < 0 {
+ n.SetInt64(-1)
+ } else {
+ n.SetInt64(1)
+ }
+
+ base.Mod(y.Abs(y), x.Mul(x.Abs(x), n))
+
+ U256(base)
+ }
+
+ stack.Push(base)
+
+ case EXP:
+ require(2)
+ x, y := stack.Popn()
+
+ base.Exp(y, x, Pow256)
+
+ U256(base)
+
+ stack.Push(base)
+ case NEG:
+ require(1)
+ base.Sub(Pow256, stack.Pop())
+
+ base = U256(base)
+
+ stack.Push(base)
+ case LT:
+ require(2)
+ x, y := stack.Popn()
+ // x < y
+ if y.Cmp(x) < 0 {
+ stack.Push(ethutil.BigTrue)
+ } else {
+ stack.Push(ethutil.BigFalse)
+ }
+ case GT:
+ require(2)
+ x, y := stack.Popn()
+
+ // x > y
+ if y.Cmp(x) > 0 {
+ stack.Push(ethutil.BigTrue)
+ } else {
+ stack.Push(ethutil.BigFalse)
+ }
+
+ case SLT:
+ require(2)
+ y, x := S256(stack.Pop()), S256(stack.Pop())
+ // x < y
+ if y.Cmp(S256(x)) < 0 {
+ stack.Push(ethutil.BigTrue)
+ } else {
+ stack.Push(ethutil.BigFalse)
+ }
+ case SGT:
+ require(2)
+ y, x := S256(stack.Pop()), S256(stack.Pop())
+
+ // x > y
+ if y.Cmp(x) > 0 {
+ stack.Push(ethutil.BigTrue)
+ } else {
+ stack.Push(ethutil.BigFalse)
+ }
+
+ case EQ:
+ require(2)
+ x, y := stack.Popn()
+
+ // x == y
+ if x.Cmp(y) == 0 {
+ stack.Push(ethutil.BigTrue)
+ } else {
+ stack.Push(ethutil.BigFalse)
+ }
+ case NOT:
+ require(1)
+ x := stack.Pop()
+ if x.Cmp(ethutil.BigFalse) > 0 {
+ stack.Push(ethutil.BigFalse)
+ } else {
+ stack.Push(ethutil.BigTrue)
+ }
+
+ // 0x10 range
+ case AND:
+ require(2)
+ x, y := stack.Popn()
+
+ stack.Push(base.And(y, x))
+ case OR:
+ require(2)
+ x, y := stack.Popn()
+
+ stack.Push(base.Or(y, x))
+ case XOR:
+ require(2)
+ x, y := stack.Popn()
+
+ stack.Push(base.Xor(y, x))
+ case BYTE:
+ require(2)
+ val, th := stack.Popn()
+ if th.Cmp(big.NewInt(32)) < 0 && th.Cmp(big.NewInt(int64(len(val.Bytes())))) < 0 {
+ byt := big.NewInt(int64(ethutil.LeftPadBytes(val.Bytes(), 32)[th.Int64()]))
+ stack.Push(byt)
+
+ } else {
+ stack.Push(ethutil.BigFalse)
+ }
+ case ADDMOD:
+ require(3)
+
+ x := stack.Pop()
+ y := stack.Pop()
+ z := stack.Pop()
+
+ base.Add(x, y)
+ base.Mod(base, z)
+
+ U256(base)
+
+ stack.Push(base)
+ case MULMOD:
+ require(3)
+
+ x := stack.Pop()
+ y := stack.Pop()
+ z := stack.Pop()
+
+ base.Mul(x, y)
+ base.Mod(base, z)
+
+ U256(base)
+
+ stack.Push(base)
+
+ // 0x20 range
+ case SHA3:
+ require(2)
+ size, offset := stack.Popn()
+ data := ethcrypto.Sha3(mem.Get(offset.Int64(), size.Int64()))
+
+ stack.Push(ethutil.BigD(data))
+
+ // 0x30 range
+ case ADDRESS:
+ stack.Push(ethutil.BigD(closure.Address()))
+
+ case BALANCE:
+ require(1)
+
+ addr := stack.Pop().Bytes()
+ balance := self.env.State().GetBalance(addr)
+
+ stack.Push(balance)
+
+ case ORIGIN:
+ origin := self.env.Origin()
+
+ stack.Push(ethutil.BigD(origin))
+
+ case CALLER:
+ caller := closure.caller.Address()
+ stack.Push(ethutil.BigD(caller))
+
+ case CALLVALUE:
+ value := closure.exe.value
+
+ stack.Push(value)
+
+ case CALLDATALOAD:
+ require(1)
+ var (
+ offset = stack.Pop()
+ data = make([]byte, 32)
+ lenData = big.NewInt(int64(len(closure.Args)))
+ )
+
+ if lenData.Cmp(offset) >= 0 {
+ length := new(big.Int).Add(offset, ethutil.Big32)
+ length = ethutil.BigMin(length, lenData)
+
+ copy(data, closure.Args[offset.Int64():length.Int64()])
+ }
+
+ stack.Push(ethutil.BigD(data))
+ case CALLDATASIZE:
+ l := int64(len(closure.Args))
+ stack.Push(big.NewInt(l))
+
+ case CALLDATACOPY:
+ var (
+ size = int64(len(closure.Args))
+ mOff = stack.Pop().Int64()
+ cOff = stack.Pop().Int64()
+ l = stack.Pop().Int64()
+ )
+
+ if cOff > size {
+ cOff = 0
+ l = 0
+ } else if cOff+l > size {
+ l = 0
+ }
+
+ code := closure.Args[cOff : cOff+l]
+
+ mem.Set(mOff, l, code)
+ case CODESIZE, EXTCODESIZE:
+ var code []byte
+ if op == EXTCODECOPY {
+ addr := stack.Pop().Bytes()
+
+ code = self.env.State().GetCode(addr)
+ } else {
+ code = closure.Code
+ }
+
+ l := big.NewInt(int64(len(code)))
+ stack.Push(l)
+
+ case CODECOPY, EXTCODECOPY:
+ var code []byte
+ if op == EXTCODECOPY {
+ addr := stack.Pop().Bytes()
+
+ code = self.env.State().GetCode(addr)
+ } else {
+ code = closure.Code
+ }
+
+ var (
+ size = int64(len(code))
+ mOff = stack.Pop().Int64()
+ cOff = stack.Pop().Int64()
+ l = stack.Pop().Int64()
+ )
+
+ if cOff > size {
+ cOff = 0
+ l = 0
+ } else if cOff+l > size {
+ l = 0
+ }
+
+ codeCopy := code[cOff : cOff+l]
+
+ mem.Set(mOff, l, codeCopy)
+ case GASPRICE:
+ stack.Push(closure.Price)
+
+ // 0x40 range
+ case PREVHASH:
+ prevHash := self.env.PrevHash()
+
+ stack.Push(ethutil.BigD(prevHash))
+
+ case COINBASE:
+ coinbase := self.env.Coinbase()
+
+ stack.Push(ethutil.BigD(coinbase))
+
+ case TIMESTAMP:
+ time := self.env.Time()
+
+ stack.Push(big.NewInt(time))
+
+ case NUMBER:
+ number := self.env.BlockNumber()
+
+ stack.Push(number)
+
+ case DIFFICULTY:
+ difficulty := self.env.Difficulty()
+
+ stack.Push(difficulty)
+
+ case GASLIMIT:
+ // TODO
+ stack.Push(big.NewInt(0))
+
+ // 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 := int(op - PUSH1 + 1)
+ val := ethutil.BigD(closure.GetBytes(int(pc+1), a))
+ // Push value to stack
+ stack.Push(val)
+
+ pc += a
+
+ step += int(op) - int(PUSH1) + 1
+ case POP:
+ require(1)
+ 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)
+ case SWAP1, SWAP2, SWAP3, SWAP4, SWAP5, SWAP6, SWAP7, SWAP8, SWAP9, SWAP10, SWAP11, SWAP12, SWAP13, SWAP14, SWAP15, SWAP16:
+ n := int(op - SWAP1 + 2)
+ stack.Swapn(n)
+
+ case MLOAD:
+ require(1)
+ offset := stack.Pop()
+ val := ethutil.BigD(mem.Get(offset.Int64(), 32))
+ stack.Push(val)
+
+ case MSTORE: // Store the value at stack top-1 in to memory at location stack top
+ require(2)
+ // Pop value of the stack
+ val, mStart := stack.Popn()
+ mem.Set(mStart.Int64(), 32, ethutil.BigToBytes(val, 256))
+
+ case MSTORE8:
+ require(2)
+ off := stack.Pop()
+ val := stack.Pop()
+
+ mem.store[off.Int64()] = byte(val.Int64() & 0xff)
+
+ case SLOAD:
+ require(1)
+ loc := stack.Pop()
+ val := closure.GetStorage(loc)
+
+ stack.Push(val.BigInt())
+
+ case SSTORE:
+ require(2)
+ val, loc := stack.Popn()
+ closure.SetStorage(loc, ethutil.NewValue(val))
+
+ closure.message.AddStorageChange(loc.Bytes())
+
+ case JUMP:
+ require(1)
+ pc = int(stack.Pop().Int64())
+ // Reduce pc by one because of the increment that's at the end of this for loop
+
+ continue
+ case JUMPI:
+ require(2)
+ cond, pos := stack.Popn()
+ if cond.Cmp(ethutil.BigTrue) >= 0 {
+ pc = int(pos.Int64())
+
+ if closure.GetOp(int(pc)) != JUMPDEST {
+ return closure.Return(nil), fmt.Errorf("JUMP missed JUMPDEST %v", pc)
+ }
+
+ continue
+ }
+ case JUMPDEST:
+ case PC:
+ stack.Push(u256(int64(pc)))
+ case MSIZE:
+ stack.Push(big.NewInt(int64(mem.Len())))
+ case GAS:
+ stack.Push(closure.Gas)
+ // 0x60 range
+ case CREATE:
+ require(3)
+
+ var (
+ err error
+ value = stack.Pop()
+ size, offset = stack.Popn()
+ input = mem.Get(offset.Int64(), size.Int64())
+ gas = new(big.Int).Set(closure.Gas)
+
+ // Snapshot the current stack so we are able to
+ // revert back to it later.
+ //snapshot = self.env.State().Copy()
+ )
+
+ // Generate a new address
+ addr := ethcrypto.CreateAddress(closure.Address(), closure.object.Nonce)
+ closure.object.Nonce++
+
+ closure.UseGas(closure.Gas)
+
+ msg := NewExecution(self, addr, input, gas, closure.Price, value)
+ ret, err := msg.Exec(addr, closure)
+ if err != nil {
+ stack.Push(ethutil.BigFalse)
+
+ // Revert the state as it was before.
+ //self.env.State().Set(snapshot)
+
+ } else {
+ msg.object.Code = ret
+
+ stack.Push(ethutil.BigD(addr))
+ }
+
+ case CALL, CALLCODE:
+ require(7)
+
+ 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 executeAddr []byte
+ if op == CALLCODE {
+ executeAddr = closure.Address()
+ } else {
+ executeAddr = addr.Bytes()
+ }
+
+ msg := NewExecution(self, executeAddr, args, gas, closure.Price, value)
+ ret, err := msg.Exec(addr.Bytes(), closure)
+ if err != nil {
+ stack.Push(ethutil.BigFalse)
+ } else {
+ stack.Push(ethutil.BigTrue)
+
+ mem.Set(retOffset.Int64(), retSize.Int64(), ret)
+ }
+
+ case RETURN:
+ require(2)
+ size, offset := stack.Popn()
+ ret := mem.Get(offset.Int64(), size.Int64())
+
+ return closure.Return(ret), nil
+ case SUICIDE:
+ require(1)
+
+ receiver := self.env.State().GetOrNewStateObject(stack.Pop().Bytes())
+
+ receiver.AddAmount(closure.object.Balance())
+
+ closure.object.MarkForDeletion()
+
+ fallthrough
+ case STOP: // Stop the closure
+
+ return closure.Return(nil), nil
+ default:
+ vmlogger.Debugf("(pc) %-3v Invalid opcode %x\n", pc, op)
+
+ //panic(fmt.Sprintf("Invalid opcode %x", op))
+
+ return closure.Return(nil), fmt.Errorf("Invalid opcode %x", op)
+ }
+
+ pc++
+ }
+}
+
+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 }
diff --git a/vm/vm_debug.go b/vm/vm_debug.go
new file mode 100644
index 0000000000000000000000000000000000000000..a30339e2bb541d23518e2aa211214a311f157d0c
--- /dev/null
+++ b/vm/vm_debug.go
@@ -0,0 +1,902 @@
+package vm
+
+import (
+ "fmt"
+ "math/big"
+
+ "github.com/ethereum/go-ethereum/ethcrypto"
+ "github.com/ethereum/go-ethereum/ethutil"
+)
+
+type DebugVm struct {
+ env Environment
+
+ logTy byte
+ logStr string
+
+ err error
+
+ // Debugging
+ Dbg Debugger
+
+ BreakPoints []int64
+ Stepping bool
+ Fn string
+
+ Recoverable bool
+
+ depth int
+}
+
+func NewDebugVm(env Environment) *DebugVm {
+ lt := LogTyPretty
+ if ethutil.Config.Diff {
+ lt = LogTyDiff
+ }
+
+ return &DebugVm{env: env, logTy: lt, Recoverable: true}
+}
+
+func (self *DebugVm) RunClosure(closure *Closure) (ret []byte, err error) {
+ self.depth++
+
+ var (
+ op OpCode
+
+ mem = &Memory{}
+ stack = NewStack()
+ pc = big.NewInt(0)
+ step = 0
+ prevStep = 0
+ state = self.env.State()
+ require = func(m int) {
+ if stack.Len() < m {
+ panic(fmt.Sprintf("%04v (%v) stack err size = %d, required = %d", pc, op, stack.Len(), m))
+ }
+ }
+
+ jump = func(pos *big.Int) {
+ p := int(pos.Int64())
+
+ self.Printf(" ~> %v", pos)
+ // Return to start
+ if p == 0 {
+ pc = big.NewInt(0)
+ } else {
+ nop := OpCode(closure.GetOp(p - 1))
+ if nop != JUMPDEST {
+ panic(fmt.Sprintf("JUMP missed JUMPDEST (%v) %v", nop, p))
+ }
+
+ pc = pos
+ }
+
+ self.Endl()
+ }
+ )
+
+ if self.Recoverable {
+ // Recover from any require exception
+ defer func() {
+ if r := recover(); r != nil {
+ self.Endl()
+
+ ret = closure.Return(nil)
+ // No error should be set. Recover is used with require
+ // Is this too error prone?
+ }
+ }()
+ }
+
+ // Debug hook
+ if self.Dbg != nil {
+ self.Dbg.SetCode(closure.Code)
+ }
+
+ // Don't bother with the execution if there's no code.
+ if len(closure.Code) == 0 {
+ return closure.Return(nil), nil
+ }
+
+ vmlogger.Debugf("(%d) %x gas: %v (d) %x\n", self.depth, closure.Address(), closure.Gas, closure.Args)
+
+ for {
+ prevStep = step
+ // The base for all big integer arithmetic
+ base := new(big.Int)
+
+ step++
+ // Get the memory location of pc
+ op = closure.GetOp(int(pc.Uint64()))
+
+ // XXX Leave this Println intact. Don't change this to the log system.
+ // Used for creating diffs between implementations
+ if self.logTy == LogTyDiff {
+ switch op {
+ case STOP, RETURN, SUICIDE:
+ state.GetStateObject(closure.Address()).EachStorage(func(key string, value *ethutil.Value) {
+ value.Decode()
+ fmt.Printf("%x %x\n", new(big.Int).SetBytes([]byte(key)).Bytes(), value.Bytes())
+ })
+ }
+
+ b := pc.Bytes()
+ if len(b) == 0 {
+ b = []byte{0}
+ }
+
+ fmt.Printf("%x %x %x %x\n", closure.Address(), b, []byte{byte(op)}, closure.Gas.Bytes())
+ }
+
+ 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
+ // Stack Check, memory resize & gas phase
+ switch op {
+ // Stack checks only
+ case NOT, CALLDATALOAD, POP, JUMP, NEG: // 1
+ require(1)
+ case ADD, SUB, DIV, SDIV, MOD, SMOD, EXP, LT, GT, SLT, SGT, EQ, AND, OR, XOR, BYTE: // 2
+ require(2)
+ case ADDMOD, MULMOD: // 3
+ require(3)
+ case SWAP1, SWAP2, SWAP3, SWAP4, SWAP5, SWAP6, SWAP7, SWAP8, SWAP9, SWAP10, SWAP11, SWAP12, SWAP13, SWAP14, SWAP15, SWAP16:
+ n := int(op - SWAP1 + 2)
+ require(n)
+ case DUP1, DUP2, DUP3, DUP4, DUP5, DUP6, DUP7, DUP8, DUP9, DUP10, DUP11, DUP12, DUP13, DUP14, DUP15, DUP16:
+ n := int(op - DUP1 + 1)
+ require(n)
+ // Gas only
+ case STOP:
+ gas.Set(ethutil.Big0)
+ case SUICIDE:
+ require(1)
+
+ gas.Set(ethutil.Big0)
+ case SLOAD:
+ gas.Set(GasSLoad)
+ // Memory resize & Gas
+ case SSTORE:
+ var mult *big.Int
+ y, x := stack.Peekn()
+ val := closure.GetStorage(x)
+ if val.BigInt().Cmp(ethutil.Big0) == 0 && len(y.Bytes()) > 0 {
+ mult = ethutil.Big2
+ } else if val.BigInt().Cmp(ethutil.Big0) != 0 && len(y.Bytes()) == 0 {
+ mult = ethutil.Big0
+ } else {
+ mult = ethutil.Big1
+ }
+ gas = new(big.Int).Mul(mult, GasSStore)
+ case BALANCE:
+ require(1)
+ gas.Set(GasBalance)
+ case MSTORE:
+ require(2)
+ newMemSize = calcMemSize(stack.Peek(), u256(32))
+ case MLOAD:
+ require(1)
+
+ newMemSize = calcMemSize(stack.Peek(), u256(32))
+ case MSTORE8:
+ require(2)
+ newMemSize = calcMemSize(stack.Peek(), u256(1))
+ case RETURN:
+ require(2)
+
+ newMemSize = calcMemSize(stack.Peek(), stack.data[stack.Len()-2])
+ case SHA3:
+ require(2)
+
+ gas.Set(GasSha)
+
+ newMemSize = calcMemSize(stack.Peek(), stack.data[stack.Len()-2])
+ case CALLDATACOPY:
+ require(2)
+
+ newMemSize = calcMemSize(stack.Peek(), stack.data[stack.Len()-3])
+ case CODECOPY:
+ require(3)
+
+ newMemSize = calcMemSize(stack.Peek(), stack.data[stack.Len()-3])
+ case EXTCODECOPY:
+ require(4)
+
+ newMemSize = calcMemSize(stack.data[stack.Len()-2], stack.data[stack.Len()-4])
+ case CALL, CALLCODE:
+ 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:
+ require(3)
+ gas.Set(GasCreate)
+
+ newMemSize = calcMemSize(stack.data[stack.Len()-2], stack.data[stack.Len()-3])
+ }
+
+ 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)
+ }
+ }
+
+ self.Printf("(pc) %-3d -o- %-14s", pc, op.String())
+ self.Printf(" (g) %-3v (%v)", gas, closure.Gas)
+
+ if !closure.UseGas(gas) {
+ self.Endl()
+
+ tmp := new(big.Int).Set(closure.Gas)
+
+ closure.UseGas(closure.Gas)
+
+ return closure.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 NEG:
+ base.Sub(Pow256, stack.Pop())
+
+ 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 NOT:
+ 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()
+
+ base.Add(x, y)
+ base.Mod(base, z)
+
+ U256(base)
+
+ self.Printf(" = %v", base)
+
+ stack.Push(base)
+ case MULMOD:
+
+ x := stack.Pop()
+ y := stack.Pop()
+ z := stack.Pop()
+
+ base.Mul(x, y)
+ base.Mod(base, z)
+
+ U256(base)
+
+ self.Printf(" = %v", base)
+
+ stack.Push(base)
+
+ // 0x20 range
+ case SHA3:
+ size, offset := stack.Popn()
+ data := ethcrypto.Sha3(mem.Get(offset.Int64(), size.Int64()))
+
+ stack.Push(ethutil.BigD(data))
+
+ self.Printf(" => %x", data)
+ // 0x30 range
+ case ADDRESS:
+ stack.Push(ethutil.BigD(closure.Address()))
+
+ self.Printf(" => %x", closure.Address())
+ case BALANCE:
+
+ addr := stack.Pop().Bytes()
+ balance := state.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 := closure.caller.Address()
+ stack.Push(ethutil.BigD(caller))
+
+ self.Printf(" => %x", caller)
+ case CALLVALUE:
+ value := closure.exe.value
+
+ stack.Push(value)
+
+ self.Printf(" => %v", value)
+ case CALLDATALOAD:
+ var (
+ offset = stack.Pop()
+ data = make([]byte, 32)
+ lenData = big.NewInt(int64(len(closure.Args)))
+ )
+
+ if lenData.Cmp(offset) >= 0 {
+ length := new(big.Int).Add(offset, ethutil.Big32)
+ length = ethutil.BigMin(length, lenData)
+
+ copy(data, closure.Args[offset.Int64():length.Int64()])
+ }
+
+ self.Printf(" => 0x%x", data)
+
+ stack.Push(ethutil.BigD(data))
+ case CALLDATASIZE:
+ l := int64(len(closure.Args))
+ stack.Push(big.NewInt(l))
+
+ self.Printf(" => %d", l)
+ case CALLDATACOPY:
+ var (
+ size = int64(len(closure.Args))
+ mOff = stack.Pop().Int64()
+ cOff = stack.Pop().Int64()
+ l = stack.Pop().Int64()
+ )
+
+ if cOff > size {
+ cOff = 0
+ l = 0
+ } else if cOff+l > size {
+ l = 0
+ }
+
+ code := closure.Args[cOff : cOff+l]
+
+ mem.Set(mOff, l, code)
+ case CODESIZE, EXTCODESIZE:
+ var code []byte
+ if op == EXTCODESIZE {
+ addr := stack.Pop().Bytes()
+
+ code = state.GetCode(addr)
+ } else {
+ code = closure.Code
+ }
+
+ l := big.NewInt(int64(len(code)))
+ stack.Push(l)
+
+ self.Printf(" => %d", l)
+ case CODECOPY, EXTCODECOPY:
+ var code []byte
+ if op == EXTCODECOPY {
+ addr := stack.Pop().Bytes()
+
+ code = state.GetCode(addr)
+ } else {
+ code = closure.Code
+ }
+
+ var (
+ size = int64(len(code))
+ mOff = stack.Pop().Int64()
+ cOff = stack.Pop().Int64()
+ l = stack.Pop().Int64()
+ )
+
+ if cOff > size {
+ cOff = 0
+ l = 0
+ } else if cOff+l > size {
+ l = 0
+ }
+
+ codeCopy := code[cOff : cOff+l]
+
+ mem.Set(mOff, l, codeCopy)
+ case GASPRICE:
+ stack.Push(closure.Price)
+
+ self.Printf(" => %v", closure.Price)
+
+ // 0x40 range
+ case PREVHASH:
+ prevHash := self.env.PrevHash()
+
+ stack.Push(ethutil.BigD(prevHash))
+
+ self.Printf(" => 0x%x", prevHash)
+ 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:
+ 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 := big.NewInt(int64(op) - int64(PUSH1) + 1)
+ pc.Add(pc, ethutil.Big1)
+ data := closure.Gets(pc, a)
+ val := ethutil.BigD(data.Bytes())
+ // Push value to stack
+ stack.Push(val)
+ pc.Add(pc, a.Sub(a, big.NewInt(1)))
+
+ step += int(op) - int(PUSH1) + 1
+
+ self.Printf(" => 0x%x", data.Bytes())
+ 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)
+ v := stack.Dupn(n)
+
+ self.Printf(" => [%d] 0x%x", n, stack.Peek().Bytes())
+
+ if OpCode(closure.Get(new(big.Int).Add(pc, ethutil.Big1)).Uint()) == POP && OpCode(closure.Get(new(big.Int).Add(pc, big.NewInt(2))).Uint()) == POP {
+ fmt.Println(toValue(v))
+ }
+ 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 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.Int64(), 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(state.GetState(closure.Address(), loc.Bytes()))
+ stack.Push(val)
+
+ self.Printf(" {0x%x : 0x%x}", loc.Bytes(), val.Bytes())
+ case SSTORE:
+ val, loc := stack.Popn()
+ state.SetState(closure.Address(), loc.Bytes(), val)
+
+ // Debug sessions are allowed to run without message
+ if closure.message != nil {
+ closure.message.AddStorageChange(loc.Bytes())
+ }
+
+ self.Printf(" {0x%x : 0x%x}", loc.Bytes(), val.Bytes())
+ case JUMP:
+
+ jump(stack.Pop())
+
+ continue
+ case JUMPI:
+ cond, pos := stack.Popn()
+
+ if cond.Cmp(ethutil.BigTrue) >= 0 {
+ jump(pos)
+
+ continue
+ }
+
+ case JUMPDEST:
+ case PC:
+ stack.Push(pc)
+ case MSIZE:
+ stack.Push(big.NewInt(int64(mem.Len())))
+ case GAS:
+ stack.Push(closure.Gas)
+ // 0x60 range
+ case CREATE:
+
+ var (
+ err error
+ value = stack.Pop()
+ size, offset = stack.Popn()
+ input = mem.Get(offset.Int64(), size.Int64())
+ gas = new(big.Int).Set(closure.Gas)
+
+ // Snapshot the current stack so we are able to
+ // revert back to it later.
+ //snapshot = self.env.State().Copy()
+ )
+
+ // Generate a new address
+ n := state.GetNonce(closure.Address())
+ addr := ethcrypto.CreateAddress(closure.Address(), n)
+ state.SetNonce(closure.Address(), n+1)
+
+ self.Printf(" (*) %x", addr).Endl()
+
+ closure.UseGas(closure.Gas)
+
+ msg := NewExecution(self, addr, input, gas, closure.Price, value)
+ ret, err := msg.Create(closure)
+ if err != nil {
+ stack.Push(ethutil.BigFalse)
+
+ // Revert the state as it was before.
+ //self.env.State().Set(snapshot)
+
+ self.Printf("CREATE err %v", err)
+ } else {
+ msg.object.Code = ret
+
+ stack.Push(ethutil.BigD(addr))
+ }
+
+ self.Endl()
+
+ // Debug hook
+ if self.Dbg != nil {
+ self.Dbg.SetCode(closure.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 executeAddr []byte
+ if op == CALLCODE {
+ executeAddr = closure.Address()
+ } else {
+ executeAddr = addr.Bytes()
+ }
+
+ msg := NewExecution(self, executeAddr, args, gas, closure.Price, value)
+ ret, err := msg.Exec(addr.Bytes(), closure)
+ if err != nil {
+ stack.Push(ethutil.BigFalse)
+
+ vmlogger.Debugln(err)
+ } else {
+ stack.Push(ethutil.BigTrue)
+
+ mem.Set(retOffset.Int64(), retSize.Int64(), ret)
+ }
+ self.Printf("resume %x", closure.Address())
+
+ // Debug hook
+ if self.Dbg != nil {
+ self.Dbg.SetCode(closure.Code)
+ }
+
+ case RETURN:
+ size, offset := stack.Popn()
+ ret := mem.Get(offset.Int64(), size.Int64())
+
+ self.Printf(" => (%d) 0x%x", len(ret), ret).Endl()
+
+ return closure.Return(ret), nil
+ case SUICIDE:
+
+ receiver := state.GetOrNewStateObject(stack.Pop().Bytes())
+
+ receiver.AddAmount(state.GetBalance(closure.Address()))
+ state.Delete(closure.Address())
+
+ fallthrough
+ case STOP: // Stop the closure
+ self.Endl()
+
+ return closure.Return(nil), nil
+ default:
+ vmlogger.Debugf("(pc) %-3v Invalid opcode %x\n", pc, op)
+
+ //panic(fmt.Sprintf("Invalid opcode %x", op))
+ closure.ReturnGas(big.NewInt(1), nil)
+
+ return closure.Return(nil), fmt.Errorf("Invalid opcode %x", op)
+ }
+
+ pc.Add(pc, ethutil.Big1)
+
+ self.Endl()
+
+ if self.Dbg != nil {
+ for _, instrNo := range self.Dbg.BreakPoints() {
+ if pc.Cmp(big.NewInt(instrNo)) == 0 {
+ self.Stepping = true
+
+ if !self.Dbg.BreakHook(prevStep, op, mem, stack, state.GetStateObject(closure.Address())) {
+ return nil, nil
+ }
+ } else if self.Stepping {
+ if !self.Dbg.StepHook(prevStep, op, mem, stack, state.GetStateObject(closure.Address())) {
+ return nil, nil
+ }
+ }
+ }
+ }
+
+ }
+}
+
+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
+}
+
+func (self *DebugVm) Depth() int {
+ return self.depth
+}
diff --git a/vm/vm_test.go b/vm/vm_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..84cca3a9d127a530c10ae6f6ada0779889d29474
--- /dev/null
+++ b/vm/vm_test.go
@@ -0,0 +1,155 @@
+package vm
+
+import (
+ "bytes"
+ "fmt"
+ "io/ioutil"
+ "log"
+ "math/big"
+ "os"
+ "testing"
+
+ "github.com/ethereum/go-ethereum/ethcrypto"
+ "github.com/ethereum/go-ethereum/ethlog"
+ "github.com/ethereum/go-ethereum/ethstate"
+ "github.com/ethereum/go-ethereum/ethtrie"
+ "github.com/ethereum/go-ethereum/ethutil"
+)
+
+type TestEnv struct {
+}
+
+func (self TestEnv) Origin() []byte { return nil }
+func (self TestEnv) BlockNumber() *big.Int { return nil }
+func (self TestEnv) BlockHash() []byte { return nil }
+func (self TestEnv) PrevHash() []byte { return nil }
+func (self TestEnv) Coinbase() []byte { return nil }
+func (self TestEnv) Time() int64 { return 0 }
+func (self TestEnv) Difficulty() *big.Int { return nil }
+func (self TestEnv) Value() *big.Int { return nil }
+
+// This is likely to fail if anything ever gets looked up in the state trie :-)
+func (self TestEnv) State() *ethstate.State { return ethstate.New(ethtrie.New(nil, "")) }
+
+const mutcode = `
+var x = 0;
+for i := 0; i < 10; i++ {
+ x = i
+}
+
+return x`
+
+func setup(level ethlog.LogLevel, typ Type) (*Closure, VirtualMachine) {
+ code, err := ethutil.Compile(mutcode, true)
+ if err != nil {
+ log.Fatal(err)
+ }
+
+ // Pipe output to /dev/null
+ ethlog.AddLogSystem(ethlog.NewStdLogSystem(ioutil.Discard, log.LstdFlags, level))
+
+ ethutil.ReadConfig(".ethtest", "/tmp/ethtest", "")
+
+ stateObject := ethstate.NewStateObject([]byte{'j', 'e', 'f', 'f'})
+ callerClosure := NewClosure(nil, stateObject, stateObject, code, big.NewInt(1000000), big.NewInt(0))
+
+ return callerClosure, New(TestEnv{}, typ)
+}
+
+func TestDebugVm(t *testing.T) {
+ closure, vm := setup(ethlog.DebugLevel, DebugVmTy)
+ ret, _, e := closure.Call(vm, nil)
+ if e != nil {
+ fmt.Println("error", e)
+ }
+
+ if ret[len(ret)-1] != 9 {
+ t.Errorf("Expected VM to return 9, got", ret, "instead.")
+ }
+}
+
+func TestVm(t *testing.T) {
+ closure, vm := setup(ethlog.DebugLevel, StandardVmTy)
+ ret, _, e := closure.Call(vm, nil)
+ if e != nil {
+ fmt.Println("error", e)
+ }
+
+ if ret[len(ret)-1] != 9 {
+ t.Errorf("Expected VM to return 9, got", ret, "instead.")
+ }
+}
+
+func BenchmarkDebugVm(b *testing.B) {
+ closure, vm := setup(ethlog.InfoLevel, DebugVmTy)
+
+ b.ResetTimer()
+
+ for i := 0; i < b.N; i++ {
+ closure.Call(vm, nil)
+ }
+}
+
+func BenchmarkVm(b *testing.B) {
+ closure, vm := setup(ethlog.InfoLevel, StandardVmTy)
+
+ b.ResetTimer()
+
+ for i := 0; i < b.N; i++ {
+ closure.Call(vm, nil)
+ }
+}
+
+func RunCode(mutCode string, typ Type) []byte {
+ code, err := ethutil.Compile(mutCode, true)
+ if err != nil {
+ log.Fatal(err)
+ }
+
+ ethlog.AddLogSystem(ethlog.NewStdLogSystem(os.Stdout, log.LstdFlags, ethlog.InfoLevel))
+
+ ethutil.ReadConfig(".ethtest", "/tmp/ethtest", "")
+
+ stateObject := ethstate.NewStateObject([]byte{'j', 'e', 'f', 'f'})
+ closure := NewClosure(nil, stateObject, stateObject, code, big.NewInt(1000000), big.NewInt(0))
+
+ vm := New(TestEnv{}, typ)
+ ret, _, e := closure.Call(vm, nil)
+ if e != nil {
+ fmt.Println(e)
+ }
+
+ return ret
+}
+
+func TestBuildInSha256(t *testing.T) {
+ ret := RunCode(`
+ var in = 42
+ var out = 0
+
+ call(0x2, 0, 10000, in, out)
+
+ return out
+ `, DebugVmTy)
+
+ exp := ethcrypto.Sha256(ethutil.LeftPadBytes([]byte{42}, 32))
+ if bytes.Compare(ret, exp) != 0 {
+ t.Errorf("Expected %x, got %x", exp, ret)
+ }
+}
+
+func TestBuildInRipemd(t *testing.T) {
+ ret := RunCode(`
+ var in = 42
+ var out = 0
+
+ call(0x3, 0, 10000, in, out)
+
+ return out
+ `, DebugVmTy)
+
+ exp := ethutil.RightPadBytes(ethcrypto.Ripemd160(ethutil.LeftPadBytes([]byte{42}, 32)), 32)
+ if bytes.Compare(ret, exp) != 0 {
+ t.Errorf("Expected %x, got %x", exp, ret)
+ }
+}
diff --git a/websocket/client.go b/websocket/client.go
new file mode 100644
index 0000000000000000000000000000000000000000..1ff0d3f648573ab3c4093cfbda8d2ae8e27b622f
--- /dev/null
+++ b/websocket/client.go
@@ -0,0 +1,122 @@
+package websocket
+
+import (
+ "fmt"
+ "io"
+
+ ws "code.google.com/p/go.net/websocket"
+)
+
+const channelBufSize = 100
+
+var maxId int = 0
+
+type MsgFunc func(c *Client, msg *Message)
+
+// Chat client.
+type Client struct {
+ id int
+ ws *ws.Conn
+ server *Server
+ ch chan *Message
+ doneCh chan bool
+
+ onMessage MsgFunc
+}
+
+// Create new chat client.
+func NewClient(ws *ws.Conn, server *Server) *Client {
+
+ if ws == nil {
+ panic("ws cannot be nil")
+ }
+
+ if server == nil {
+ panic("server cannot be nil")
+ }
+
+ maxId++
+ ch := make(chan *Message, channelBufSize)
+ doneCh := make(chan bool)
+
+ return &Client{maxId, ws, server, ch, doneCh, nil}
+}
+
+func (c *Client) Id() int {
+ return c.id
+}
+
+func (c *Client) Conn() *ws.Conn {
+ return c.ws
+}
+
+func (c *Client) Write(data interface{}, seed int) {
+ msg := &Message{Seed: seed, Data: data}
+ select {
+ case c.ch <- msg:
+ default:
+ c.server.Del(c)
+ err := fmt.Errorf("client %d is disconnected.", c.id)
+ c.server.Err(err)
+ }
+}
+
+func (c *Client) Done() {
+ c.doneCh <- true
+}
+
+// Listen Write and Read request via chanel
+func (c *Client) Listen() {
+ go c.listenWrite()
+ c.listenRead()
+}
+
+// Listen write request via chanel
+func (c *Client) listenWrite() {
+ logger.Debugln("Listening write to client")
+ for {
+ select {
+
+ // send message to the client
+ case msg := <-c.ch:
+ logger.Debugln("Send:", msg)
+ ws.JSON.Send(c.ws, msg)
+
+ // receive done request
+ case <-c.doneCh:
+ c.server.Del(c)
+ c.doneCh <- true // for listenRead method
+ return
+ }
+ }
+}
+
+// Listen read request via chanel
+func (c *Client) listenRead() {
+ logger.Debugln("Listening read from client")
+ for {
+ select {
+
+ // receive done request
+ case <-c.doneCh:
+ c.server.Del(c)
+ c.doneCh <- true // for listenWrite method
+ return
+
+ // read data from ws connection
+ default:
+ var msg Message
+ err := ws.JSON.Receive(c.ws, &msg)
+ if err == io.EOF {
+ c.doneCh <- true
+ } else if err != nil {
+ c.server.Err(err)
+ } else {
+ logger.Debugln(&msg)
+ if c.onMessage != nil {
+ c.onMessage(c, &msg)
+ }
+ }
+ }
+ }
+}
diff --git a/websocket/message.go b/websocket/message.go
new file mode 100644
index 0000000000000000000000000000000000000000..67289c4c49964c5310fba53eb3cdebfb81449365
--- /dev/null
+++ b/websocket/message.go
@@ -0,0 +1,14 @@
+package websocket
+
+import "github.com/ethereum/go-ethereum/ethutil"
+
+type Message struct {
+ Call string `json:"call"`
+ Args []interface{} `json:"args"`
+ Seed int `json:"seed"`
+ Data interface{} `json:"data"`
+}
+
+func (self *Message) Arguments() *ethutil.Value {
+ return ethutil.NewValue(self.Args)
+}
diff --git a/websocket/server.go b/websocket/server.go
new file mode 100644
index 0000000000000000000000000000000000000000..1b4c00433f2565dc7a0ca99f11c8b0e6feae2915
--- /dev/null
+++ b/websocket/server.go
@@ -0,0 +1,127 @@
+package websocket
+
+import (
+ "net/http"
+
+ "github.com/ethereum/go-ethereum/ethlog"
+
+ ws "code.google.com/p/go.net/websocket"
+)
+
+var logger = ethlog.NewLogger("WS")
+
+// Chat server.
+type Server struct {
+ httpServ string
+ pattern string
+ messages []*Message
+ clients map[int]*Client
+ addCh chan *Client
+ delCh chan *Client
+ sendAllCh chan string
+ doneCh chan bool
+ errCh chan error
+ msgFunc MsgFunc
+}
+
+// Create new chat server.
+func NewServer(pattern, httpServ string) *Server {
+ clients := make(map[int]*Client)
+ addCh := make(chan *Client)
+ delCh := make(chan *Client)
+ sendAllCh := make(chan string)
+ doneCh := make(chan bool)
+ errCh := make(chan error)
+
+ return &Server{
+ httpServ,
+ pattern,
+ nil,
+ clients,
+ addCh,
+ delCh,
+ sendAllCh,
+ doneCh,
+ errCh,
+ nil,
+ }
+}
+
+func (s *Server) Add(c *Client) {
+ s.addCh <- c
+}
+
+func (s *Server) Del(c *Client) {
+ s.delCh <- c
+}
+
+func (s *Server) SendAll(msg string) {
+ s.sendAllCh <- msg
+}
+
+func (s *Server) Done() {
+ s.doneCh <- true
+}
+
+func (s *Server) Err(err error) {
+ s.errCh <- err
+}
+
+func (s *Server) servHTTP() {
+ logger.Debugln("Serving http", s.httpServ)
+ err := http.ListenAndServe(s.httpServ, nil)
+
+ logger.Warnln(err)
+}
+
+func (s *Server) MessageFunc(f MsgFunc) {
+ s.msgFunc = f
+}
+
+// Listen and serve.
+// It serves client connection and broadcast request.
+func (s *Server) Listen() {
+ logger.Debugln("Listening server...")
+
+ // ws handler
+ onConnected := func(ws *ws.Conn) {
+ defer func() {
+ err := ws.Close()
+ if err != nil {
+ s.errCh <- err
+ }
+ }()
+
+ client := NewClient(ws, s)
+ client.onMessage = s.msgFunc
+ s.Add(client)
+ client.Listen()
+ }
+ // Disable Origin check. Request don't need to come necessarily from origin.
+ http.HandleFunc(s.pattern, func(w http.ResponseWriter, req *http.Request) {
+ s := ws.Server{Handler: ws.Handler(onConnected)}
+ s.ServeHTTP(w, req)
+ })
+ logger.Debugln("Created handler")
+
+ go s.servHTTP()
+
+ for {
+ select {
+
+ // Add new a client
+ case c := <-s.addCh:
+ s.clients[c.id] = c
+
+ // del a client
+ case c := <-s.delCh:
+ delete(s.clients, c.id)
+
+ case err := <-s.errCh:
+ logger.Debugln("Error:", err.Error())
+
+ case <-s.doneCh:
+ return
+ }
+ }
+}