Merge

ethchain/dagger.go

@@ -11,7 +11,7 @@ import (
 )
 
 type PoW interface {
-	Search(block *Block, breakChan chan bool) []byte
+	Search(block *Block, minerChan chan ethutil.React) []byte
 	Verify(hash []byte, diff *big.Int, nonce []byte) bool
 }
 
@@ -19,19 +19,32 @@ type EasyPow struct {
 	hash *big.Int
 }
 
-func (pow *EasyPow) Search(block *Block, breakChan chan bool) []byte {
+func (pow *EasyPow) Search(block *Block, minerChan chan ethutil.React) []byte {
 	r := rand.New(rand.NewSource(time.Now().UnixNano()))
 	hash := block.HashNoNonce()
 	diff := block.Difficulty
+	i := int64(0)
+	start := time.Now().UnixNano()
 
 	for {
 		select {
-		case shouldbreak := <-breakChan:
-			if shouldbreak {
-				log.Println("Got signal: Breaking out mining.")
+		case chanMessage := <-minerChan:
+			if _, ok := chanMessage.Resource.(*Block); ok {
+				log.Println("BREAKING OUT: BLOCK")
+				return nil
+			}
+			if _, ok := chanMessage.Resource.(*Transaction); ok {
+				log.Println("BREAKING OUT: TX")
 				return nil
 			}
 		default:
+			i++
+			if i%1234567 == 0 {
+				elapsed := time.Now().UnixNano() - start
+				hashes := ((float64(1e9) / float64(elapsed)) * float64(i)) / 1000
+				log.Println("Hashing @", int64(hashes), "khash")
+			}
+
 			sha := ethutil.Sha3Bin(big.NewInt(r.Int63()).Bytes())
 			if pow.Verify(hash, diff, sha) {
 				return sha

ethchain/keypair.go

@@ -0,0 +1,74 @@
+package ethchain
+
+import (
+	"github.com/ethereum/eth-go/ethutil"
+	"math/big"
+)
+
+type KeyPair struct {
+	PrivateKey []byte
+	PublicKey  []byte
+
+	// The associated account
+	account *Account
+	state   *State
+}
+
+func NewKeyPairFromValue(val *ethutil.Value) *KeyPair {
+	keyPair := &KeyPair{PrivateKey: val.Get(0).Bytes(), PublicKey: val.Get(1).Bytes()}
+
+	return keyPair
+}
+
+func (k *KeyPair) Address() []byte {
+	return ethutil.Sha3Bin(k.PublicKey[1:])[12:]
+}
+
+func (k *KeyPair) Account() *Account {
+	if k.account == nil {
+		k.account = k.state.GetAccount(k.Address())
+	}
+
+	return k.account
+}
+
+// Create transaction, creates a new and signed transaction, ready for processing
+func (k *KeyPair) CreateTx(receiver []byte, value *big.Int, data []string) *Transaction {
+	tx := NewTransaction(receiver, value, data)
+	tx.Nonce = k.account.Nonce
+
+	// Sign the transaction with the private key in this key chain
+	tx.Sign(k.PrivateKey)
+
+	return tx
+}
+
+func (k *KeyPair) RlpEncode() []byte {
+	return ethutil.EmptyValue().Append(k.PrivateKey).Append(k.PublicKey).Encode()
+}
+
+type KeyRing struct {
+	keys []*KeyPair
+}
+
+func (k *KeyRing) Add(pair *KeyPair) {
+	k.keys = append(k.keys, pair)
+}
+
+// The public "singleton" keyring
+var keyRing *KeyRing
+
+func GetKeyRing(state *State) *KeyRing {
+	if keyRing == nil {
+		keyRing = &KeyRing{}
+
+		data, _ := ethutil.Config.Db.Get([]byte("KeyRing"))
+		it := ethutil.NewValueFromBytes(data).NewIterator()
+		for it.Next() {
+			v := it.Value()
+			keyRing.Add(NewKeyPairFromValue(v))
+		}
+	}
+
+	return keyRing
+}

ethchain/state_manager.go

@@ -22,7 +22,6 @@ type EthManager interface {
 	Reactor() *ethutil.ReactorEngine
 }
 
-// TODO rename to state manager
 type StateManager struct {
 	// Mutex for locking the block processor. Blocks can only be handled one at a time
 	mutex sync.Mutex