diff --git a/big.go b/big.go
deleted file mode 100644
index b0fbcb64fa742c145ed3f00152614de44114a7a6..0000000000000000000000000000000000000000
--- a/big.go
+++ /dev/null
@@ -1,35 +0,0 @@
-package main
-
-import (
- "math/big"
-)
-
-/*
- * Returns the power of two 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
-}
-
-/*
- * Like big.NewInt(uint64); this takes a string instead.
- */
-func Big(num string) *big.Int {
- n := new(big.Int)
- n.SetString(num, 0)
-
- return n
-}
-
-/*
- * Like big.NewInt(uint64); this takes a byte buffer instead.
- */
-func BigD(data []byte) *big.Int {
- n := new(big.Int)
- n.SetBytes(data)
-
- return n
-}
diff --git a/block.go b/block.go
deleted file mode 100644
index 2287a9d559bd99dc0e4df8b2316853cf65229535..0000000000000000000000000000000000000000
--- a/block.go
+++ /dev/null
@@ -1,192 +0,0 @@
-package main
-
-import (
- "fmt"
- "time"
- _"bytes"
- _"encoding/hex"
-)
-
-type Block struct {
- // The number of this block
- number uint32
- // Hash to the previous block
- prevHash string
- // Uncles of this block
- uncles []*Block
- coinbase string
- // state xxx
- state *Trie
- difficulty uint32
- // Creation time
- time int64
- nonce uint32
- // List of transactions and/or contracts
- transactions []*Transaction
-
- extra string
-}
-
-// New block takes a raw encoded string
-func NewBlock(raw []byte) *Block {
- block := &Block{}
- block.UnmarshalRlp(raw)
-
- return block
-}
-
-// Creates a new block. This is currently for testing
-func CreateTestBlock(/* TODO use raw data */transactions []*Transaction) *Block {
- block := &Block{
- // Slice of transactions to include in this block
- transactions: transactions,
- number: 1,
- prevHash: "1234",
- coinbase: "me",
- difficulty: 10,
- nonce: 0,
- time: time.Now().Unix(),
- }
-
- return block
-}
-
-func CreateBlock(root string,
- num int,
- prevHash string,
- base string,
- difficulty int,
- nonce int,
- extra string,
- txes []*Transaction) *Block {
-
- block := &Block{
- // Slice of transactions to include in this block
- transactions: txes,
- number: uint32(num),
- prevHash: prevHash,
- coinbase: base,
- difficulty: uint32(difficulty),
- nonce: uint32(nonce),
- time: time.Now().Unix(),
- extra: extra,
- }
- block.state = NewTrie(Db, root)
-
- for _, tx := range txes {
- // Create contract if there's no recipient
- if tx.recipient == "" {
- addr := tx.Hash()
-
- contract := NewContract(tx.value, []byte(""))
- block.state.Update(string(addr), string(contract.MarshalRlp()))
- for i, val := range tx.data {
- contract.state.Update(string(NumberToBytes(uint64(i), 32)), val)
- }
- block.UpdateContract(addr, contract)
- }
- }
-
- return block
-}
-
-func (block *Block) GetContract(addr []byte) *Contract {
- data := block.state.Get(string(addr))
- if data == "" {
- return nil
- }
-
- contract := &Contract{}
- contract.UnmarshalRlp([]byte(data))
-
- return contract
-}
-
-func (block *Block) UpdateContract(addr []byte, contract *Contract) {
- block.state.Update(string(addr), string(contract.MarshalRlp()))
-}
-
-
-func (block *Block) PayFee(addr []byte, fee uint64) bool {
- contract := block.GetContract(addr)
- // If we can't pay the fee return
- if contract == nil || contract.amount < fee {
- fmt.Println("Contract has insufficient funds", contract.amount, fee)
-
- return false
- }
-
- contract.amount -= fee
- block.state.Update(string(addr), string(contract.MarshalRlp()))
-
- data := block.state.Get(string(block.coinbase))
-
- // Get the ether (coinbase) and add the fee (gief fee to miner)
- ether := NewEtherFromData([]byte(data))
- ether.amount += fee
-
- block.state.Update(string(block.coinbase), string(ether.MarshalRlp()))
-
- return true
-}
-
-// Returns a hash of the block
-func (block *Block) Hash() []byte {
- return Sha256Bin(block.MarshalRlp())
-}
-
-func (block *Block) MarshalRlp() []byte {
- // Marshal the transactions of this block
- encTx := make([]string, len(block.transactions))
- for i, tx := range block.transactions {
- // Cast it to a string (safe)
- encTx[i] = string(tx.MarshalRlp())
- }
- // TODO
- uncles := []interface{}{}
-
- // I made up the block. It should probably contain different data or types.
- // It sole purpose now is testing
- header := []interface{}{
- block.number,
- block.prevHash,
- // Sha of uncles
- "",
- block.coinbase,
- // root state
- block.state.root,
- // Sha of tx
- string(Sha256Bin([]byte(Encode(encTx)))),
- block.difficulty,
- uint64(block.time),
- block.nonce,
- block.extra,
- }
-
- // Encode a slice interface which contains the header and the list of
- // transactions.
- return Encode([]interface{}{header, encTx, uncles})
-}
-
-func (block *Block) UnmarshalRlp(data []byte) {
- decoder := NewRlpDecoder(data)
-
- header := decoder.Get(0)
- block.number = uint32(header.Get(0).AsUint())
- block.prevHash = header.Get(1).AsString()
- // sha of uncles is header[2]
- block.coinbase = header.Get(3).AsString()
- block.state = NewTrie(Db, header.Get(4).AsString())
- block.difficulty = uint32(header.Get(5).AsUint())
- block.time = int64(header.Get(6).AsUint())
- block.nonce = uint32(header.Get(7).AsUint())
- block.extra = header.Get(8).AsString()
-
- txes := decoder.Get(1)
- block.transactions = make([]*Transaction, txes.Length())
- for i := 0; i < txes.Length(); i++ {
- tx := &Transaction{}
- tx.UnmarshalRlp(txes.Get(i).AsBytes())
- block.transactions[i] = tx
- }
-}
diff --git a/block_manager.go b/block_manager.go
index 134ca0e75eef955b89afa6b3e427fea45f49b6ed..59430dca74b0eb2b7f07d85a755885d7f3d1646d 100644
--- a/block_manager.go
+++ b/block_manager.go
@@ -2,17 +2,18 @@ package main
import (
"fmt"
+ "github.com/ethereum/ethutil-go"
)
type BlockChain struct {
- lastBlock *Block
+ lastBlock *ethutil.Block
- genesisBlock *Block
+ genesisBlock *ethutil.Block
}
func NewBlockChain() *BlockChain {
bc := &BlockChain{}
- bc.genesisBlock = NewBlock( Encode(Genesis) )
+ bc.genesisBlock = ethutil.NewBlock( ethutil.Encode(ethutil.Genesis) )
return bc
}
@@ -30,19 +31,19 @@ func NewBlockManager() *BlockManager {
}
// Process a block.
-func (bm *BlockManager) ProcessBlock(block *Block) error {
+func (bm *BlockManager) ProcessBlock(block *ethutil.Block) error {
// TODO Validation (Or move to other part of the application)
if err := bm.ValidateBlock(block); err != nil {
return err
}
// Get the tx count. Used to create enough channels to 'join' the go routines
- txCount := len(block.transactions)
+ txCount := len(block.Transactions())
// Locking channel. When it has been fully buffered this method will return
lockChan := make(chan bool, txCount)
// Process each transaction/contract
- for _, tx := range block.transactions {
+ for _, tx := range block.Transactions() {
// If there's no recipient, it's a contract
if tx.IsContract() {
go bm.ProcessContract(tx, block, lockChan)
@@ -60,11 +61,11 @@ func (bm *BlockManager) ProcessBlock(block *Block) error {
return nil
}
-func (bm *BlockManager) ValidateBlock(block *Block) error {
+func (bm *BlockManager) ValidateBlock(block *ethutil.Block) error {
return nil
}
-func (bm *BlockManager) ProcessContract(tx *Transaction, block *Block, lockChan chan bool) {
+func (bm *BlockManager) ProcessContract(tx *ethutil.Transaction, block *ethutil.Block, lockChan chan bool) {
// Recovering function in case the VM had any errors
defer func() {
if r := recover(); r != nil {
diff --git a/bytes.go b/bytes.go
deleted file mode 100644
index 6bf38134301fa0ee28e085338a4001c6037770b3..0000000000000000000000000000000000000000
--- a/bytes.go
+++ /dev/null
@@ -1,27 +0,0 @@
-package main
-
-import (
- "bytes"
- "encoding/binary"
- "fmt"
-)
-
-func NumberToBytes(num uint64, bits int) []byte {
- buf := new(bytes.Buffer)
- err := binary.Write(buf, binary.BigEndian, num)
- if err != nil {
- fmt.Println("binary.Write failed:", err)
- }
-
- return buf.Bytes()[buf.Len()-(bits / 8):]
-}
-
-func BytesToNumber(b []byte) (number uint64) {
- buf := bytes.NewReader(b)
- err := binary.Read(buf, binary.LittleEndian, &number)
- if err != nil {
- fmt.Println("binary.Read failed:", err)
- }
-
- return
-}
diff --git a/contract.go b/contract.go
deleted file mode 100644
index a54643f590cf1a705ca98a5c8f50f287b8abcf95..0000000000000000000000000000000000000000
--- a/contract.go
+++ /dev/null
@@ -1,65 +0,0 @@
-package main
-
-import (
- _"fmt"
-)
-
-type Contract struct {
- t uint32 // contract is always 1
- amount uint64 // ???
- state *Trie
-}
-
-func NewContract(amount uint64, root []byte) *Contract {
- contract := &Contract{t: 1, amount: amount}
- contract.state = NewTrie(Db, string(root))
-
- return contract
-}
-
-func (c *Contract) MarshalRlp() []byte {
- return Encode([]interface{}{c.t, c.amount, c.state.root})
-}
-
-func (c *Contract) UnmarshalRlp(data []byte) {
- decoder := NewRlpDecoder(data)
-
- c.t = uint32(decoder.Get(0).AsUint())
- c.amount = decoder.Get(1).AsUint()
- c.state = NewTrie(Db, decoder.Get(2).AsString())
-}
-
-type Ether struct {
- t uint32
- amount uint64
- nonce string
-}
-
-func NewEtherFromData(data []byte) *Ether {
- ether := &Ether{}
- ether.UnmarshalRlp(data)
-
- return ether
-}
-
-func (e *Ether) MarshalRlp() []byte {
- return Encode([]interface{}{e.t, e.amount, e.nonce})
-}
-
-func (e *Ether) UnmarshalRlp(data []byte) {
- t, _ := Decode(data, 0)
-
- if slice, ok := t.([]interface{}); ok {
- if t, ok := slice[0].(uint8); ok {
- e.t = uint32(t)
- }
-
- if amount, ok := slice[1].(uint8); ok {
- e.amount = uint64(amount)
- }
-
- if nonce, ok := slice[2].([]uint8); ok {
- e.nonce = string(nonce)
- }
- }
-}
diff --git a/dagger.go b/dagger.go
index 2c1976840b9d6ba0a7e13e6eb51c8451497f4d06..5aa5dd7551b7c74797e797481459360cac08708b 100644
--- a/dagger.go
+++ b/dagger.go
@@ -6,6 +6,7 @@ import (
"time"
"github.com/obscuren/sha3"
"hash"
+ "github.com/ethereum/ethutil-go"
)
type Dagger struct {
@@ -40,7 +41,7 @@ func (dag *Dagger) Search(hash, diff *big.Int) *big.Int {
dag.hash = hash
- obj := BigPow(2, 256)
+ obj := ethutil.BigPow(2, 256)
obj = obj.Div(obj, diff)
Found = false
@@ -66,7 +67,7 @@ func DaggerVerify(hash, diff, nonce *big.Int) bool {
dagger := &Dagger{}
dagger.hash = hash
- obj := BigPow(2, 256)
+ obj := ethutil.BigPow(2, 256)
obj = obj.Div(obj, diff)
return dagger.Eval(nonce).Cmp(obj) < 0
@@ -114,7 +115,7 @@ func Sum(sha hash.Hash) []byte {
}
func (dag *Dagger) Eval(N *big.Int) *big.Int {
- pow := BigPow(2, 26)
+ pow := ethutil.BigPow(2, 26)
dag.xn = N.Div(N, pow)
sha := sha3.NewKeccak256()
diff --git a/database.go b/database.go
deleted file mode 100644
index b147756b61b8c822dc16f7c1dfeaefdcd1cc9f3a..0000000000000000000000000000000000000000
--- a/database.go
+++ /dev/null
@@ -1,56 +0,0 @@
-package main
-
-import (
- "path"
- "os/user"
- "github.com/syndtr/goleveldb/leveldb"
- "fmt"
-)
-
-type LDBDatabase struct {
- db *leveldb.DB
- trie *Trie
-}
-
-func NewLDBDatabase() (*LDBDatabase, error) {
- // This will eventually have to be something like a resource folder.
- // it works on my system for now. Probably won't work on Windows
- usr, _ := user.Current()
- dbPath := path.Join(usr.HomeDir, ".ethereum", "database")
-
- // Open the db
- db, err := leveldb.OpenFile(dbPath, nil)
- if err != nil {
- return nil, err
- }
-
- database := &LDBDatabase{db: db}
-
- // Bootstrap database. Sets a few defaults; such as the last block
- database.Bootstrap()
-
- return database, nil
-}
-
-func (db *LDBDatabase) Bootstrap() error {
- //db.trie = NewTrie(db)
-
- return 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 nil, nil
-}
-
-func (db *LDBDatabase) Close() {
- // Close the leveldb database
- db.db.Close()
-}
-
diff --git a/database_test.go b/database_test.go
deleted file mode 100644
index 1a46eb95eeda6abff487dfacac7ead510b3a817c..0000000000000000000000000000000000000000
--- a/database_test.go
+++ /dev/null
@@ -1,7 +0,0 @@
-package main
-
-import (
- _"testing"
- _"fmt"
-)
-
diff --git a/dev_console.go b/dev_console.go
index 65166c0c1d3312a26c36c279719aeef888976322..27fc2e65ea5ac81765f7d46070c286f647b01464 100644
--- a/dev_console.go
+++ b/dev_console.go
@@ -7,16 +7,18 @@ import (
"os"
"errors"
"encoding/hex"
+ "github.com/ethereum/ethdb-go"
+ "github.com/ethereum/ethutil-go"
)
type Console struct {
- db *MemDatabase
- trie *Trie
+ db *ethdb.MemDatabase
+ trie *ethutil.Trie
}
func NewConsole() *Console {
- db, _ := NewMemDatabase()
- trie := NewTrie(db, "")
+ db, _ := ethdb.NewMemDatabase()
+ trie := ethutil.NewTrie(db, "")
return &Console{db: db, trie: trie}
}
@@ -68,17 +70,19 @@ func (i *Console) ParseInput(input string) bool {
case "update":
i.trie.Update(tokens[1], tokens[2])
- fmt.Println(hex.EncodeToString([]byte(i.trie.root)))
+ fmt.Println(hex.EncodeToString([]byte(i.trie.Root)))
case "get":
fmt.Println(i.trie.Get(tokens[1]))
case "root":
- fmt.Println(hex.EncodeToString([]byte(i.trie.root)))
+ fmt.Println(hex.EncodeToString([]byte(i.trie.Root)))
case "rawroot":
- fmt.Println(i.trie.root)
+ fmt.Println(i.trie.Root)
case "print":
i.db.Print()
case "dag":
- fmt.Println(DaggerVerify(Big(tokens[1]), BigPow(2, 36), Big(tokens[2])))
+ fmt.Println(DaggerVerify( ethutil.Big(tokens[1]), // hash
+ ethutil.BigPow(2, 36), // diff
+ ethutil.Big(tokens[2])))// nonce
case "exit", "quit", "q":
return false
case "help":
diff --git a/encoding.go b/encoding.go
deleted file mode 100644
index d77303817b0051c1c754919017b6c50feb27f0e0..0000000000000000000000000000000000000000
--- a/encoding.go
+++ /dev/null
@@ -1,62 +0,0 @@
-package main
-
-import (
- "bytes"
- "encoding/hex"
- "strings"
- _"fmt"
-)
-
-func CompactEncode(hexSlice []int) string {
- terminator := 0
- if hexSlice[len(hexSlice)-1] == 16 {
- terminator = 1
- }
-
- if terminator == 1 {
- hexSlice = hexSlice[:len(hexSlice)-1]
- }
-
- oddlen := len(hexSlice) % 2
- flags := 2 * terminator + oddlen
- if oddlen != 0 {
- hexSlice = append([]int{flags}, hexSlice...)
- } else {
- hexSlice = append([]int{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) []int {
- base := CompactHexDecode(str)
- base = base[:len(base)-1]
- if base[0] >= 2 {// && base[len(base)-1] != 16 {
- base = append(base, 16)
- }
- if base[0] % 2 == 1 {
- base = base[1:]
- } else {
- base = base[2:]
- }
-
- return base
-}
-
-func CompactHexDecode(str string) []int {
- base := "0123456789abcdef"
- hexSlice := make([]int, 0)
-
- enc := hex.EncodeToString([]byte(str))
- for _, v := range enc {
- hexSlice = append(hexSlice, strings.IndexByte(base, byte(v)))
- }
- hexSlice = append(hexSlice, 16)
-
- return hexSlice
-}
diff --git a/encoding_test.go b/encoding_test.go
deleted file mode 100644
index b66f702acbf21667d77306b2d4414d5d19b03d70..0000000000000000000000000000000000000000
--- a/encoding_test.go
+++ /dev/null
@@ -1,38 +0,0 @@
-package main
-
-import (
- "testing"
- "fmt"
-)
-
-func TestCompactEncode(t *testing.T) {
- test1 := []int{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 := []int{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 := []int{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 := []int{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 := []int{7, 6, 6, 5, 7, 2, 6, 2, 16}
- res := CompactHexDecode("verb")
-
- if !CompareIntSlice(res, exp) {
- t.Error("Error compact hex decode. Expected", exp, "got", res)
- }
-}
diff --git a/ethereum.go b/ethereum.go
index aee8ebc30fcf530badc7861c35d53e83dd9da245..96b67f970528475c9d3c096ccfdc4f6fa6edc5a2 100644
--- a/ethereum.go
+++ b/ethereum.go
@@ -7,7 +7,7 @@ import (
"flag"
"runtime"
"log"
- _"math/big"
+ "github.com/ethereum/ethutil-go"
)
const Debug = true
@@ -39,7 +39,7 @@ func RegisterInterupts(s *Server) {
func main() {
runtime.GOMAXPROCS(runtime.NumCPU())
- InitFees()
+ ethutil.InitFees()
Init()
@@ -63,7 +63,7 @@ func main() {
go func() {
for {
- res := dagger.Search(Big("0"), BigPow(2, 36))
+ res := dagger.Search(ethutil.Big("0"), ethutil.BigPow(2, 36))
server.Broadcast("block", Encode(res.String()))
}
}()
diff --git a/genesis.go b/genesis.go
deleted file mode 100644
index 21b8e9998f521833c6a997c5c29b227c899882fb..0000000000000000000000000000000000000000
--- a/genesis.go
+++ /dev/null
@@ -1,34 +0,0 @@
-package main
-
-import (
- "math"
-)
-
-/*
- * This is the special genesis block.
- */
-
-var GenisisHeader = []interface{}{
- // Block number
- uint32(0),
- // Previous hash (none)
- "",
- // Sha of uncles
- string(Sha256Bin(Encode([]interface{}{}))),
- // Coinbase
- "",
- // Root state
- "",
- // Sha of transactions
- string(Sha256Bin(Encode([]interface{}{}))),
- // Difficulty
- uint32(math.Pow(2, 36)),
- // Time
- uint64(1),
- // Nonce
- uint32(0),
- // Extra
- "",
-}
-
-var Genesis = []interface{}{ GenisisHeader, []interface{}{}, []interface{}{} }
diff --git a/memory_database.go b/memory_database.go
deleted file mode 100644
index a8c74bb46a30b4afe8ab4be77ca7da40d676dd48..0000000000000000000000000000000000000000
--- a/memory_database.go
+++ /dev/null
@@ -1,34 +0,0 @@
-package main
-
-import (
- "fmt"
-)
-
-/*
- * 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) Print() {
- for key, val := range db.db {
- fmt.Printf("%x(%d):", key, len(key))
- decoded := DecodeNode(val)
- PrintSlice(decoded)
- }
-}
diff --git a/parsing.go b/parsing.go
deleted file mode 100644
index b97d77f3e4e2efb5d7ea4f69f251097282bea928..0000000000000000000000000000000000000000
--- a/parsing.go
+++ /dev/null
@@ -1,98 +0,0 @@
-package main
-
-import (
- "fmt"
- "strings"
- "errors"
- "math/big"
- "strconv"
-)
-
-// Op codes
-var OpCodes = map[string]string{
- "STOP": "0",
- "ADD": "1",
- "MUL": "2",
- "SUB": "3",
- "DIV": "4",
- "SDIV": "5",
- "MOD": "6",
- "SMOD": "7",
- "EXP": "8",
- "NEG": "9",
- "LT": "10",
- "LE": "11",
- "GT": "12",
- "GE": "13",
- "EQ": "14",
- "NOT": "15",
- "MYADDRESS": "16",
- "TXSENDER": "17",
-
-
- "PUSH": "48",
- "POP": "49",
- "LOAD": "54",
-}
-
-
-func CompileInstr(s string) (string, error) {
- tokens := strings.Split(s, " ")
- if OpCodes[tokens[0]] == "" {
- return s, errors.New(fmt.Sprintf("OP not found: %s", tokens[0]))
- }
-
- code := OpCodes[tokens[0]] // Replace op codes with the proper numerical equivalent
- op := new(big.Int)
- op.SetString(code, 0)
-
- args := make([]*big.Int, 6)
- for i, val := range tokens[1:len(tokens)] {
- num := new(big.Int)
- num.SetString(val, 0)
- args[i] = num
- }
-
- // Big int equation = op + x * 256 + y * 256**2 + z * 256**3 + a * 256**4 + b * 256**5 + c * 256**6
- base := new(big.Int)
- x := new(big.Int)
- y := new(big.Int)
- z := new(big.Int)
- a := new(big.Int)
- b := new(big.Int)
- c := new(big.Int)
-
- if args[0] != nil { x.Mul(args[0], big.NewInt(256)) }
- if args[1] != nil { y.Mul(args[1], BigPow(256, 2)) }
- if args[2] != nil { z.Mul(args[2], BigPow(256, 3)) }
- if args[3] != nil { a.Mul(args[3], BigPow(256, 4)) }
- if args[4] != nil { b.Mul(args[4], BigPow(256, 5)) }
- if args[5] != nil { c.Mul(args[5], BigPow(256, 6)) }
-
- base.Add(op, x)
- base.Add(base, y)
- base.Add(base, z)
- base.Add(base, a)
- base.Add(base, b)
- base.Add(base, c)
-
- return base.String(), nil
-}
-
-func Instr(instr string) (int, []string, error) {
- base := new(big.Int)
- base.SetString(instr, 0)
-
- args := make([]string, 7)
- for i := 0; i < 7; i++ {
- // int(int(val) / int(math.Pow(256,float64(i)))) % 256
- exp := BigPow(256, i)
- num := new(big.Int)
- num.Div(base, exp)
-
- args[i] = num.Mod(num, big.NewInt(256)).String()
- }
- op, _ := strconv.Atoi(args[0])
-
- return op, args[1:7], nil
-}
diff --git a/parsing_test.go b/parsing_test.go
deleted file mode 100644
index 6aa9e240cb18e923280756bd951e7fe620e6be7c..0000000000000000000000000000000000000000
--- a/parsing_test.go
+++ /dev/null
@@ -1,33 +0,0 @@
-package main
-
-import (
- "testing"
- "math"
-)
-
-func TestCompile(t *testing.T) {
- instr, err := CompileInstr("PUSH")
-
- if err != nil {
- t.Error("Failed compiling instruction")
- }
-
- calc := (48 + 0 * 256 + 0 * int64(math.Pow(256,2)))
- if Big(instr).Int64() != calc {
- t.Error("Expected", calc, ", got:", instr)
- }
-}
-
-func TestValidInstr(t *testing.T) {
- /*
- op, args, err := Instr("68163")
- if err != nil {
- t.Error("Error decoding instruction")
- }
- */
-
-}
-
-func TestInvalidInstr(t *testing.T) {
-}
-
diff --git a/rlp.go b/rlp.go
index 5366632f4f064fd9591aeee13b6fbb818d6e398c..cee9da61312ea4b094b60bff67ad0d8ee5eea3ea 100644
--- a/rlp.go
+++ b/rlp.go
@@ -5,6 +5,7 @@ import (
"bytes"
"math"
"math/big"
+ "github.com/ethereum/ethutil-go"
)
type RlpEncoder struct {
@@ -54,7 +55,7 @@ func (attr *RlpDataAttribute) AsUint() uint64 {
func (attr *RlpDataAttribute) AsBigInt() *big.Int {
if a, ok := attr.dataAttrib.([]byte); ok {
- return Big(string(a))
+ return ethutil.Big(string(a))
}
return big.NewInt(0)
diff --git a/server.go b/server.go
index c2903cb59bc35644289eb76a9629ee1846b7b072..d81fe1bceaedc18f7cb30b27ff4e514a8c99c36c 100644
--- a/server.go
+++ b/server.go
@@ -5,15 +5,15 @@ import (
"net"
"log"
_"time"
+ "github.com/ethereum/ethdb-go"
+ "github.com/ethereum/ethutil-go"
)
-var Db *LDBDatabase
-
type Server struct {
// Channel for shutting down the server
shutdownChan chan bool
// DB interface
- db *LDBDatabase
+ db *ethdb.LDBDatabase
// Block manager for processing new blocks and managing the block chain
blockManager *BlockManager
// Peers (NYI)
@@ -21,12 +21,12 @@ type Server struct {
}
func NewServer() (*Server, error) {
- db, err := NewLDBDatabase()
+ db, err := ethdb.NewLDBDatabase()
if err != nil {
return nil, err
}
- Db = db
+ ethutil.SetConfig(db)
server := &Server{
shutdownChan: make(chan bool),
diff --git a/transaction.go b/transaction.go
deleted file mode 100644
index 90e0d98696ca52ca30ac81f9fe98b02e4bc8f469..0000000000000000000000000000000000000000
--- a/transaction.go
+++ /dev/null
@@ -1,206 +0,0 @@
-package main
-
-import (
- "math/big"
- "fmt"
- "github.com/obscuren/secp256k1-go"
- _"encoding/hex"
- _"crypto/sha256"
- _ "bytes"
-)
-
-/*
-Transaction Contract Size
--------------------------------------------
-sender sender 20 bytes
-recipient 0x0 20 bytes
-value endowment 4 bytes (uint32)
-fee fee 4 bytes (uint32)
-d_size o_size 4 bytes (uint32)
-data ops *
-signature signature 64 bytes
-*/
-
-var StepFee *big.Int = new(big.Int)
-var TxFee *big.Int = new(big.Int)
-var ContractFee *big.Int = new(big.Int)
-var MemFee *big.Int = new(big.Int)
-var DataFee *big.Int = new(big.Int)
-var CryptoFee *big.Int = new(big.Int)
-var ExtroFee *big.Int = new(big.Int)
-
-var Period1Reward *big.Int = new(big.Int)
-var Period2Reward *big.Int = new(big.Int)
-var Period3Reward *big.Int = new(big.Int)
-var Period4Reward *big.Int = new(big.Int)
-
-type Transaction struct {
- nonce string
- sender string
- recipient string
- value uint64
- fee uint32
- data []string
- memory []int
- lastTx string
- v uint32
- r, s []byte
-}
-
-func NewTransaction(to string, value uint64, data []string) *Transaction {
- tx := Transaction{sender: "1234567890", recipient: to, value: value}
- tx.nonce = "0"
- tx.fee = 0//uint32((ContractFee + MemoryFee * float32(len(tx.data))) * 1e8)
- tx.lastTx = "0"
-
- // Serialize the data
- tx.data = make([]string, len(data))
- for i, val := range data {
- instr, err := CompileInstr(val)
- if err != nil {
- //fmt.Printf("compile error:%d %v\n", i+1, err)
- }
-
- tx.data[i] = instr
- }
-
- tx.Sign([]byte("privkey"))
- tx.Sender()
-
-
- return &tx
-}
-
-func (tx *Transaction) Hash() []byte {
- preEnc := []interface{}{
- tx.nonce,
- tx.recipient,
- tx.value,
- tx.fee,
- tx.data,
- }
-
- return Sha256Bin(Encode(preEnc))
-}
-
-func (tx *Transaction) IsContract() bool {
- return tx.recipient == ""
-}
-
-func (tx *Transaction) Signature(key []byte) []byte {
- hash := tx.Hash()
- sec := Sha256Bin(key)
-
- sig, _ := secp256k1.Sign(hash, sec)
-
- return sig
-}
-
-func (tx *Transaction) PublicKey() []byte {
- hash := Sha256Bin(tx.Hash())
- sig := append(tx.r, tx.s...)
-
- 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 (04 = full, 03 = compact)
- if pubkey[0] != 4 {
- return nil
- }
-
- return Sha256Bin(pubkey[1:65])[12:]
-}
-
-func (tx *Transaction) Sign(privk []byte) {
- sig := tx.Signature(privk)
-
- // Add 27 so we get either 27 or 28 (for positive and negative)
- tx.v = uint32(sig[64]) + 27
- tx.r = sig[:32]
- tx.s = sig[32:65]
-}
-
-func (tx *Transaction) MarshalRlp() []byte {
- // Prepare the transaction for serialization
- preEnc := []interface{}{
- tx.nonce,
- tx.recipient,
- tx.value,
- tx.fee,
- tx.data,
- tx.v,
- tx.r,
- tx.s,
- }
-
- return Encode(preEnc)
-}
-
-func (tx *Transaction) UnmarshalRlp(data []byte) {
- decoder := NewRlpDecoder(data)
-
- tx.nonce = decoder.Get(0).AsString()
- tx.recipient = decoder.Get(0).AsString()
- tx.value = decoder.Get(2).AsUint()
- tx.fee = uint32(decoder.Get(3).AsUint())
-
- d := decoder.Get(4)
- tx.data = make([]string, d.Length())
- fmt.Println(d.Get(0))
- for i := 0; i < d.Length(); i++ {
- tx.data[i] = d.Get(i).AsString()
- }
-
- tx.v = uint32(decoder.Get(5).AsUint())
- tx.r = decoder.Get(6).AsBytes()
- tx.s = decoder.Get(7).AsBytes()
-}
-
-func InitFees() {
- // Base for 2**60
- b60 := new(big.Int)
- b60.Exp(big.NewInt(2), big.NewInt(64), big.NewInt(0))
- // Base for 2**80
- b80 := new(big.Int)
- b80.Exp(big.NewInt(2), big.NewInt(80), big.NewInt(0))
-
- StepFee.Exp(big.NewInt(10), big.NewInt(16), big.NewInt(0))
- //StepFee.Div(b60, big.NewInt(64))
- //fmt.Println("StepFee:", StepFee)
-
- TxFee.Exp(big.NewInt(2), big.NewInt(64), big.NewInt(0))
- //fmt.Println("TxFee:", TxFee)
-
- ContractFee.Exp(big.NewInt(2), big.NewInt(64), big.NewInt(0))
- //fmt.Println("ContractFee:", ContractFee)
-
- MemFee.Div(b60, big.NewInt(4))
- //fmt.Println("MemFee:", MemFee)
-
- DataFee.Div(b60, big.NewInt(16))
- //fmt.Println("DataFee:", DataFee)
-
- CryptoFee.Div(b60, big.NewInt(16))
- //fmt.Println("CrytoFee:", CryptoFee)
-
- ExtroFee.Div(b60, big.NewInt(16))
- //fmt.Println("ExtroFee:", ExtroFee)
-
- Period1Reward.Mul(b80, big.NewInt(1024))
- //fmt.Println("Period1Reward:", Period1Reward)
-
- Period2Reward.Mul(b80, big.NewInt(512))
- //fmt.Println("Period2Reward:", Period2Reward)
-
- Period3Reward.Mul(b80, big.NewInt(256))
- //fmt.Println("Period3Reward:", Period3Reward)
-
- Period4Reward.Mul(b80, big.NewInt(128))
- //fmt.Println("Period4Reward:", Period4Reward)
-}
diff --git a/trie.go b/trie.go
deleted file mode 100644
index d66699eeb66e7f2a745e159da2b268a21e796d75..0000000000000000000000000000000000000000
--- a/trie.go
+++ /dev/null
@@ -1,203 +0,0 @@
-package main
-
-import (
- "fmt"
-)
-
-// Database interface
-type Database interface {
- Put(key []byte, value []byte)
- Get(key []byte) ([]byte, error)
-}
-
-/*
- * Trie helper functions
- */
-// Helper function for printing out the raw contents of a slice
-func PrintSlice(slice []string) {
- fmt.Printf("[")
- for i, val := range slice {
- fmt.Printf("%q", val)
- if i != len(slice)-1 { fmt.Printf(",") }
- }
- fmt.Printf("]\n")
-}
-
-// RLP Decodes a node in to a [2] or [17] string slice
-func DecodeNode(data []byte) []string {
- dec, _ := Decode(data, 0)
- if slice, ok := dec.([]interface{}); ok {
- strSlice := make([]string, len(slice))
-
- for i, s := range slice {
- if str, ok := s.([]byte); ok {
- strSlice[i] = string(str)
- }
- }
-
- return strSlice
- } else {
- fmt.Printf("It wasn't a []. It's a %T\n", dec)
- }
-
- return nil
-}
-
-// A (modified) Radix Trie implementation
-type Trie struct {
- root string
- db Database
-}
-
-func NewTrie(db Database, root string) *Trie {
- return &Trie{db: db, root: root}
-}
-
-/*
- * Public (query) interface functions
- */
-func (t *Trie) Update(key string, value string) {
- k := CompactHexDecode(key)
-
- t.root = t.UpdateState(t.root, k, value)
-}
-
-func (t *Trie) Get(key string) string {
- k := CompactHexDecode(key)
-
- return t.GetState(t.root, k)
-}
-
-/*
- * State functions (shouldn't be needed directly).
- */
-
-// Helper function for printing a node (using fetch, decode and slice printing)
-func (t *Trie) PrintNode(n string) {
- data, _ := t.db.Get([]byte(n))
- d := DecodeNode(data)
- PrintSlice(d)
-}
-
-// Returns the state of an object
-func (t *Trie) GetState(node string, key []int) string {
- // Return the node if key is empty (= found)
- if len(key) == 0 || node == "" {
- return node
- }
-
- // Fetch the encoded node from the db
- n, err := t.db.Get([]byte(node))
- if err != nil { fmt.Println("Error in GetState for node", node, "with key", key); return "" }
-
- // Decode it
- currentNode := DecodeNode(n)
-
- if len(currentNode) == 0 {
- return ""
- } else if len(currentNode) == 2 {
- // Decode the key
- k := CompactDecode(currentNode[0])
- v := currentNode[1]
-
- if len(key) >= len(k) && CompareIntSlice(k, key[:len(k)]) {
- return t.GetState(v, key[len(k):])
- } else {
- return ""
- }
- } else if len(currentNode) == 17 {
- return t.GetState(currentNode[key[0]], key[1:])
- }
-
- // It shouldn't come this far
- fmt.Println("GetState unexpected return")
- return ""
-}
-
-// Inserts a new sate or delete a state based on the value
-func (t *Trie) UpdateState(node string, key []int, value string) string {
- if value != "" {
- return t.InsertState(node, key, value)
- } else {
- // delete it
- }
-
- return ""
-}
-
-// Wrapper around the regular db "Put" which generates a key and value
-func (t *Trie) Put(node interface{}) []byte {
- enc := Encode(node)
- var sha []byte
- sha = Sha256Bin(enc)
-
- t.db.Put([]byte(sha), enc)
-
- return sha
-}
-
-func (t *Trie) InsertState(node string, key []int, value string) string {
- if len(key) == 0 {
- return value
- }
-
- // New node
- if node == "" {
- newNode := []string{ CompactEncode(key), value }
-
- return string(t.Put(newNode))
- }
-
- // Fetch the encoded node from the db
- n, err := t.db.Get([]byte(node))
- if err != nil { fmt.Println("Error InsertState", err); return "" }
-
- // Decode it
- currentNode := DecodeNode(n)
- // Check for "special" 2 slice type node
- if len(currentNode) == 2 {
- // Decode the key
- k := CompactDecode(currentNode[0])
- v := currentNode[1]
-
- // Matching key pair (ie. there's already an object with this key)
- if CompareIntSlice(k, key) {
- return string(t.Put([]string{ CompactEncode(key), value }))
- }
-
- var newHash string
- 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 := make([]string, 17)
- // Set the copied and new node
- scaledSlice[k[matchingLength]] = oldNode
- scaledSlice[key[matchingLength]] = newNode
-
- newHash = string(t.Put(scaledSlice))
- }
-
- if matchingLength == 0 {
- // End of the chain, return
- return newHash
- } else {
- newNode := []string{ CompactEncode(key[:matchingLength]), newHash }
- return string(t.Put(newNode))
- }
- } else {
- // Copy the current node over to the new node and replace the first nibble in the key
- newNode := make([]string, 17); copy(newNode, currentNode)
- newNode[key[0]] = t.InsertState(currentNode[key[0]], key[1:], value)
-
- return string(t.Put(newNode))
- }
-
- return ""
-}
-
diff --git a/trie_test.go b/trie_test.go
deleted file mode 100644
index 599a5f47cf13c158300345b9208218a97d5ef4a7..0000000000000000000000000000000000000000
--- a/trie_test.go
+++ /dev/null
@@ -1,59 +0,0 @@
-package main
-
-import (
- "testing"
- "encoding/hex"
- _"fmt"
-)
-
-func TestTriePut(t *testing.T) {
- db, err := NewMemDatabase()
- trie := NewTrie(db, "")
-
- if err != nil {
- t.Error("Error starting db")
- }
-
- key := trie.Put([]byte("testing node"))
-
- data, err := db.Get(key)
- if err != nil {
- t.Error("Nothing at node")
- }
-
- s, _ := Decode(data, 0)
- if str, ok := s.([]byte); ok {
- if string(str) != "testing node" {
- t.Error("Wrong value node", str)
- }
- } else {
- t.Error("Invalid return type")
- }
-}
-
-func TestTrieUpdate(t *testing.T) {
- db, err := NewMemDatabase()
- trie := NewTrie(db, "")
-
- if err != nil {
- t.Error("Error starting db")
- }
-
-
- trie.Update("doe", "reindeer")
- trie.Update("dog", "puppy")
- /*
- data, _ := db.Get([]byte(trie.root))
- data, _ = db.Get([]byte(DecodeNode(data)[1]))
- data, _ = db.Get([]byte(DecodeNode(data)[7]))
- PrintSlice(DecodeNode(data))
- */
-
- trie.Update("dogglesworth", "cat")
- root := hex.EncodeToString([]byte(trie.root))
- req := "e378927bfc1bd4f01a2e8d9f59bd18db8a208bb493ac0b00f93ce51d4d2af76c"
- if root != req {
- t.Error("trie.root do not match, expected", req, "got", root)
- }
-}
-
diff --git a/util.go b/util.go
deleted file mode 100644
index 24e5455f45c8f6136cf8e7e63d441386d77f5b9d..0000000000000000000000000000000000000000
--- a/util.go
+++ /dev/null
@@ -1,63 +0,0 @@
-package main
-
-import (
- "strconv"
- "crypto/sha256"
- "encoding/hex"
- _"fmt"
- _"math"
- "github.com/obscuren/sha3"
-)
-
-func Uitoa(i uint32) string {
- return strconv.FormatUint(uint64(i), 10)
-}
-
-func Sha256Hex(data []byte) string {
- hash := sha256.Sum256(data)
-
- return hex.EncodeToString(hash[:])
-}
-
-func Sha256Bin(data []byte) []byte {
- hash := sha256.Sum256(data)
-
- return hash[:]
-}
-
-func Sha3Bin(data []byte) []byte {
- d := sha3.NewKeccak224()
- d.Reset()
- d.Write(data)
-
- return d.Sum(nil)
-}
-
-// 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 []int) int {
- i := 0
- for CompareIntSlice(a[:i+1], b[:i+1]) && i < len(b) {
- i+=1
- }
-
- //fmt.Println(a, b, i-1)
-
- return i
-}
-
-func Hex(d []byte) string {
- return hex.EncodeToString(d)
-}
diff --git a/vm.go b/vm.go
index 5b70f354425706dc8091dcb246abbcb4dcdd1b45..5605cb7c7974b404ea81c54fdfb147b726287cb9 100644
--- a/vm.go
+++ b/vm.go
@@ -1,12 +1,10 @@
package main
import (
- _"math"
"math/big"
"fmt"
- _"strconv"
- _ "encoding/hex"
"strconv"
+ "github.com/ethereum/ethutil-go"
)
// Op codes
@@ -93,7 +91,7 @@ func (st *Stack) Popn() (*big.Int, *big.Int) {
strs := st.data[s-2:]
st.data = st.data[:s-2]
- return Big(strs[0]), Big(strs[1])
+ return ethutil.Big(strs[0]), ethutil.Big(strs[1])
}
func (st *Stack) Push(d string) {
@@ -114,7 +112,8 @@ func NewVm() *Vm {
}
}
-func (vm *Vm) ProcContract(tx *Transaction, block *Block, cb TxCallback) {
+func (vm *Vm) ProcContract( tx *ethutil.Transaction,
+ block *ethutil.Block, cb TxCallback) {
// Instruction pointer
pc := 0
@@ -124,7 +123,7 @@ func (vm *Vm) ProcContract(tx *Transaction, block *Block, cb TxCallback) {
return
}
- Pow256 := BigPow(2, 256)
+ Pow256 := ethutil.BigPow(2, 256)
//fmt.Printf("# op arg\n")
out:
@@ -134,7 +133,8 @@ out:
// XXX Should Instr return big int slice instead of string slice?
// Get the next instruction from the contract
//op, _, _ := Instr(contract.state.Get(string(Encode(uint32(pc)))))
- op, _, _ := Instr(contract.state.Get(string(NumberToBytes(uint64(pc), 32))))
+ nb := ethutil.NumberToBytes(uint64(pc), 32)
+ op, _, _ := ethutil.Instr(contract.State().Get(string(nb)))
if !cb(0) { break }
@@ -200,7 +200,7 @@ out:
vm.stack.Push(base.String())
case oNEG:
- base.Sub(Pow256, Big(vm.stack.Pop()))
+ base.Sub(Pow256, ethutil.Big(vm.stack.Pop()))
vm.stack.Push(base.String())
case oLT:
x, y := vm.stack.Popn()
@@ -245,18 +245,18 @@ out:
case oMYADDRESS:
vm.stack.Push(string(tx.Hash()))
case oTXSENDER:
- vm.stack.Push(tx.sender)
+ vm.stack.Push(string(tx.Sender()))
case oPUSH:
// Get the next entry and pushes the value on the stack
pc++
- vm.stack.Push(contract.state.Get(string(NumberToBytes(uint64(pc), 32))))
+ vm.stack.Push(contract.State().Get(string(ethutil.NumberToBytes(uint64(pc), 32))))
case oPOP:
// Pop current value of the stack
vm.stack.Pop()
case oLOAD:
// Load instruction X on the stack
i, _ := strconv.Atoi(vm.stack.Pop())
- vm.stack.Push(contract.state.Get(string(NumberToBytes(uint64(i), 32))))
+ vm.stack.Push(contract.State().Get(string(ethutil.NumberToBytes(uint64(i), 32))))
case oSTOP:
break out
}