Skip to content

G
Geth-Modification
Commit 8bbf879c authored by obscuren's avatar obscuren
Browse files
Options

Moving the ethgo to individual packages

parent f6fa4f88
Hide whitespace changes
Inline Side-by-side
Showing with 46 additions and 1251 deletions
big.go deleted 100644 → 0
View file @ f6fa4f88
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
}
block.go deleted 100644 → 0
View file @ f6fa4f88
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
}
}
block_manager.go
View file @ 8bbf879c
...@@ -2,17 +2,18 @@ package main ...@@ -2,17 +2,18 @@ package main
import ( import (
"fmt" "fmt"
"github.com/ethereum/ethutil-go"
) )
type BlockChain struct { type BlockChain struct {
lastBlock *Block lastBlock *ethutil.Block
genesisBlock *Block genesisBlock *ethutil.Block
} }
func NewBlockChain() *BlockChain { func NewBlockChain() *BlockChain {
bc := &BlockChain{} bc := &BlockChain{}
bc.genesisBlock = NewBlock( Encode(Genesis) ) bc.genesisBlock = ethutil.NewBlock( ethutil.Encode(ethutil.Genesis) )
return bc return bc
} }
...@@ -30,19 +31,19 @@ func NewBlockManager() *BlockManager { ...@@ -30,19 +31,19 @@ func NewBlockManager() *BlockManager {
} }
// Process a block. // 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) // TODO Validation (Or move to other part of the application)
if err := bm.ValidateBlock(block); err != nil { if err := bm.ValidateBlock(block); err != nil {
return err return err
} }
// Get the tx count. Used to create enough channels to 'join' the go routines // 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 // Locking channel. When it has been fully buffered this method will return
lockChan := make(chan bool, txCount) lockChan := make(chan bool, txCount)
// Process each transaction/contract // Process each transaction/contract
for _, tx := range block.transactions { for _, tx := range block.Transactions() {
// If there's no recipient, it's a contract // If there's no recipient, it's a contract
if tx.IsContract() { if tx.IsContract() {
go bm.ProcessContract(tx, block, lockChan) go bm.ProcessContract(tx, block, lockChan)
...@@ -60,11 +61,11 @@ func (bm *BlockManager) ProcessBlock(block *Block) error { ...@@ -60,11 +61,11 @@ func (bm *BlockManager) ProcessBlock(block *Block) error {
return nil return nil
} }
func (bm *BlockManager) ValidateBlock(block *Block) error { func (bm *BlockManager) ValidateBlock(block *ethutil.Block) error {
return nil 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 // Recovering function in case the VM had any errors
defer func() { defer func() {
if r := recover(); r != nil { if r := recover(); r != nil {
......
bytes.go deleted 100644 → 0
View file @ f6fa4f88
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
}
contract.go deleted 100644 → 0
View file @ f6fa4f88
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)
}
}
}
dagger.go
View file @ 8bbf879c
...@@ -6,6 +6,7 @@ import ( ...@@ -6,6 +6,7 @@ import (
"time" "time"
"github.com/obscuren/sha3" "github.com/obscuren/sha3"
"hash" "hash"
"github.com/ethereum/ethutil-go"
) )
type Dagger struct { type Dagger struct {
...@@ -40,7 +41,7 @@ func (dag *Dagger) Search(hash, diff *big.Int) *big.Int { ...@@ -40,7 +41,7 @@ func (dag *Dagger) Search(hash, diff *big.Int) *big.Int {
dag.hash = hash dag.hash = hash
obj := BigPow(2, 256) obj := ethutil.BigPow(2, 256)
obj = obj.Div(obj, diff) obj = obj.Div(obj, diff)
Found = false Found = false
...@@ -66,7 +67,7 @@ func DaggerVerify(hash, diff, nonce *big.Int) bool { ...@@ -66,7 +67,7 @@ func DaggerVerify(hash, diff, nonce *big.Int) bool {
dagger := &Dagger{} dagger := &Dagger{}
dagger.hash = hash dagger.hash = hash
obj := BigPow(2, 256) obj := ethutil.BigPow(2, 256)
obj = obj.Div(obj, diff) obj = obj.Div(obj, diff)
return dagger.Eval(nonce).Cmp(obj) < 0 return dagger.Eval(nonce).Cmp(obj) < 0
...@@ -114,7 +115,7 @@ func Sum(sha hash.Hash) []byte { ...@@ -114,7 +115,7 @@ func Sum(sha hash.Hash) []byte {
} }
func (dag *Dagger) Eval(N *big.Int) *big.Int { func (dag *Dagger) Eval(N *big.Int) *big.Int {
pow := BigPow(2, 26) pow := ethutil.BigPow(2, 26)
dag.xn = N.Div(N, pow) dag.xn = N.Div(N, pow)
sha := sha3.NewKeccak256() sha := sha3.NewKeccak256()
......
database.go deleted 100644 → 0
View file @ f6fa4f88
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()
}
database_test.go deleted 100644 → 0
View file @ f6fa4f88
package main
import (
_"testing"
_"fmt"
)
dev_console.go
View file @ 8bbf879c
...@@ -7,16 +7,18 @@ import ( ...@@ -7,16 +7,18 @@ import (
"os" "os"
"errors" "errors"
"encoding/hex" "encoding/hex"
"github.com/ethereum/ethdb-go"
"github.com/ethereum/ethutil-go"
) )
type Console struct { type Console struct {
db *MemDatabase db *ethdb.MemDatabase
trie *Trie trie *ethutil.Trie
} }
func NewConsole() *Console { func NewConsole() *Console {
db, _ := NewMemDatabase() db, _ := ethdb.NewMemDatabase()
trie := NewTrie(db, "") trie := ethutil.NewTrie(db, "")
return &Console{db: db, trie: trie} return &Console{db: db, trie: trie}
} }
...@@ -68,17 +70,19 @@ func (i *Console) ParseInput(input string) bool { ...@@ -68,17 +70,19 @@ func (i *Console) ParseInput(input string) bool {
case "update": case "update":
i.trie.Update(tokens[1], tokens[2]) 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": case "get":
fmt.Println(i.trie.Get(tokens[1])) fmt.Println(i.trie.Get(tokens[1]))
case "root": case "root":
fmt.Println(hex.EncodeToString([]byte(i.trie.root))) fmt.Println(hex.EncodeToString([]byte(i.trie.Root)))
case "rawroot": case "rawroot":
fmt.Println(i.trie.root) fmt.Println(i.trie.Root)
case "print": case "print":
i.db.Print() i.db.Print()
case "dag": 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": case "exit", "quit", "q":
return false return false
case "help": case "help":
......
encoding.go deleted 100644 → 0
View file @ f6fa4f88
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
}
encoding_test.go deleted 100644 → 0
View file @ f6fa4f88
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)
}
}
ethereum.go
View file @ 8bbf879c
...@@ -7,7 +7,7 @@ import ( ...@@ -7,7 +7,7 @@ import (
"flag" "flag"
"runtime" "runtime"
"log" "log"
_"math/big" "github.com/ethereum/ethutil-go"
) )
const Debug = true const Debug = true
...@@ -39,7 +39,7 @@ func RegisterInterupts(s *Server) { ...@@ -39,7 +39,7 @@ func RegisterInterupts(s *Server) {
func main() { func main() {
runtime.GOMAXPROCS(runtime.NumCPU()) runtime.GOMAXPROCS(runtime.NumCPU())
InitFees() ethutil.InitFees()
Init() Init()
...@@ -63,7 +63,7 @@ func main() { ...@@ -63,7 +63,7 @@ func main() {
go func() { go func() {
for { 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())) server.Broadcast("block", Encode(res.String()))
} }
}() }()
......
genesis.go deleted 100644 → 0
View file @ f6fa4f88
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{}{} }
memory_database.go deleted 100644 → 0
View file @ f6fa4f88
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)
}
}
parsing.go deleted 100644 → 0
View file @ f6fa4f88
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
}
parsing_test.go deleted 100644 → 0
View file @ f6fa4f88
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) {
}
rlp.go
View file @ 8bbf879c
...@@ -5,6 +5,7 @@ import ( ...@@ -5,6 +5,7 @@ import (
"bytes" "bytes"
"math" "math"
"math/big" "math/big"
"github.com/ethereum/ethutil-go"
) )
type RlpEncoder struct { type RlpEncoder struct {
...@@ -54,7 +55,7 @@ func (attr *RlpDataAttribute) AsUint() uint64 { ...@@ -54,7 +55,7 @@ func (attr *RlpDataAttribute) AsUint() uint64 {
func (attr *RlpDataAttribute) AsBigInt() *big.Int { func (attr *RlpDataAttribute) AsBigInt() *big.Int {
if a, ok := attr.dataAttrib.([]byte); ok { if a, ok := attr.dataAttrib.([]byte); ok {
return Big(string(a)) return ethutil.Big(string(a))
} }
return big.NewInt(0) return big.NewInt(0)
......
server.go
View file @ 8bbf879c
...@@ -5,15 +5,15 @@ import ( ...@@ -5,15 +5,15 @@ import (
"net" "net"
"log" "log"
_"time" _"time"
"github.com/ethereum/ethdb-go"
"github.com/ethereum/ethutil-go"
) )
var Db *LDBDatabase
type Server struct { type Server struct {
// Channel for shutting down the server // Channel for shutting down the server
shutdownChan chan bool shutdownChan chan bool
// DB interface // DB interface
db *LDBDatabase db *ethdb.LDBDatabase
// Block manager for processing new blocks and managing the block chain // Block manager for processing new blocks and managing the block chain
blockManager *BlockManager blockManager *BlockManager
// Peers (NYI) // Peers (NYI)
...@@ -21,12 +21,12 @@ type Server struct { ...@@ -21,12 +21,12 @@ type Server struct {
} }
func NewServer() (*Server, error) { func NewServer() (*Server, error) {
db, err := NewLDBDatabase() db, err := ethdb.NewLDBDatabase()
if err != nil { if err != nil {
return nil, err return nil, err
} }
Db = db ethutil.SetConfig(db)
server := &Server{ server := &Server{
shutdownChan: make(chan bool), shutdownChan: make(chan bool),
......
transaction.go deleted 100644 → 0
View file @ f6fa4f88
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)
}
trie.go deleted 100644 → 0
View file @ f6fa4f88
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 ""
}
trie_test.go deleted 100644 → 0
View file @ f6fa4f88
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)
}
}
util.go deleted 100644 → 0
View file @ f6fa4f88
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)
}
vm.go
View file @ 8bbf879c
package main package main
import ( import (
_"math"
"math/big" "math/big"
"fmt" "fmt"
_"strconv"
_ "encoding/hex"
"strconv" "strconv"
"github.com/ethereum/ethutil-go"
) )
// Op codes // Op codes
...@@ -93,7 +91,7 @@ func (st *Stack) Popn() (*big.Int, *big.Int) { ...@@ -93,7 +91,7 @@ func (st *Stack) Popn() (*big.Int, *big.Int) {
strs := st.data[s-2:] strs := st.data[s-2:]
st.data = 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) { func (st *Stack) Push(d string) {
...@@ -114,7 +112,8 @@ func NewVm() *Vm { ...@@ -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 // Instruction pointer
pc := 0 pc := 0
...@@ -124,7 +123,7 @@ func (vm *Vm) ProcContract(tx *Transaction, block *Block, cb TxCallback) { ...@@ -124,7 +123,7 @@ func (vm *Vm) ProcContract(tx *Transaction, block *Block, cb TxCallback) {
return return
} }
Pow256 := BigPow(2, 256) Pow256 := ethutil.BigPow(2, 256)
//fmt.Printf("# op arg\n") //fmt.Printf("# op arg\n")
out: out:
...@@ -134,7 +133,8 @@ out: ...@@ -134,7 +133,8 @@ out:
// XXX Should Instr return big int slice instead of string slice? // XXX Should Instr return big int slice instead of string slice?
// Get the next instruction from the contract // Get the next instruction from the contract
//op, _, _ := Instr(contract.state.Get(string(Encode(uint32(pc))))) //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 } if !cb(0) { break }
...@@ -200,7 +200,7 @@ out: ...@@ -200,7 +200,7 @@ out:
vm.stack.Push(base.String()) vm.stack.Push(base.String())
case oNEG: case oNEG:
base.Sub(Pow256, Big(vm.stack.Pop())) base.Sub(Pow256, ethutil.Big(vm.stack.Pop()))
vm.stack.Push(base.String()) vm.stack.Push(base.String())
case oLT: case oLT:
x, y := vm.stack.Popn() x, y := vm.stack.Popn()
...@@ -245,18 +245,18 @@ out: ...@@ -245,18 +245,18 @@ out:
case oMYADDRESS: case oMYADDRESS:
vm.stack.Push(string(tx.Hash())) vm.stack.Push(string(tx.Hash()))
case oTXSENDER: case oTXSENDER:
vm.stack.Push(tx.sender) vm.stack.Push(string(tx.Sender()))
case oPUSH: case oPUSH:
// Get the next entry and pushes the value on the stack // Get the next entry and pushes the value on the stack
pc++ 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: case oPOP:
// Pop current value of the stack // Pop current value of the stack
vm.stack.Pop() vm.stack.Pop()
case oLOAD: case oLOAD:
// Load instruction X on the stack // Load instruction X on the stack
i, _ := strconv.Atoi(vm.stack.Pop()) 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: case oSTOP:
break out break out
} }
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment