Added address states for storing a session based address

ethchain/address.go

+package ethchain
+
+import (
+	"github.com/ethereum/eth-go/ethutil"
+	"math/big"
+)
+
+type Address struct {
+	Amount *big.Int
+	Nonce  uint64
+}
+
+func NewAddress(amount *big.Int) *Address {
+	return &Address{Amount: amount, Nonce: 0}
+}
+
+func NewAddressFromData(data []byte) *Address {
+	address := &Address{}
+	address.RlpDecode(data)
+
+	return address
+}
+
+func (a *Address) AddFee(fee *big.Int) {
+	a.Amount.Add(a.Amount, fee)
+}
+
+func (a *Address) RlpEncode() []byte {
+	return ethutil.Encode([]interface{}{a.Amount, a.Nonce})
+}
+
+func (a *Address) RlpDecode(data []byte) {
+	decoder := ethutil.NewValueFromBytes(data)
+
+	a.Amount = decoder.Get(0).BigInt()
+	a.Nonce = decoder.Get(1).Uint()
+}
+
+type AddrStateStore struct {
+	states map[string]*AddressState
+}
+
+func NewAddrStateStore() *AddrStateStore {
+	return &AddrStateStore{states: make(map[string]*AddressState)}
+}
+
+func (s *AddrStateStore) Add(addr []byte, account *Address) *AddressState {
+	state := &AddressState{Nonce: account.Nonce, Account: account}
+	s.states[string(addr)] = state
+	return state
+}
+
+func (s *AddrStateStore) Get(addr []byte) *AddressState {
+	return s.states[string(addr)]
+}
+
+type AddressState struct {
+	Nonce   uint64
+	Account *Address
+}

ethchain/address_test.go

+package ethchain
+
+import (
+	"testing"
+)
+
+func TestAddressState(t *testing.T) {
+}

ethchain/block_manager.go

@@ -5,7 +5,7 @@ import (
 	"encoding/hex"
 	"fmt"
 	"github.com/ethereum/eth-go/ethutil"
-	"github.com/ethereum/eth-go/ethwire"
+	_ "github.com/ethereum/eth-go/ethwire"
 	"github.com/obscuren/secp256k1-go"
 	"log"
 	"math"
@@ -19,6 +19,7 @@ type BlockProcessor interface {
 	ProcessBlock(block *Block)
 }
 
+// TODO rename to state manager
 type BlockManager struct {
 	// Mutex for locking the block processor. Blocks can only be handled one at a time
 	mutex sync.Mutex
@@ -26,6 +27,10 @@ type BlockManager struct {
 	// The block chain :)
 	bc *BlockChain
 
+	// States for addresses. You can watch any address
+	// at any given time
+	addrStateStore *AddrStateStore
+
 	// Stack for processing contracts
 	stack *Stack
 	// non-persistent key/value memory storage
@@ -63,6 +68,7 @@ func NewBlockManager(speaker PublicSpeaker) *BlockManager {
 		mem:            make(map[string]*big.Int),
 		Pow:            &EasyPow{},
 		Speaker:        speaker,
+		addrStateStore: NewAddrStateStore(),
 	}
 
 	if bm.bc.CurrentBlock == nil {
@@ -81,6 +87,22 @@ func NewBlockManager(speaker PublicSpeaker) *BlockManager {
 	return bm
 }
 
+// Watches any given address and puts it in the address state store
+func (bm *BlockManager) WatchAddr(addr []byte) *AddressState {
+	account := bm.bc.CurrentBlock.GetAddr(addr)
+
+	return bm.addrStateStore.Add(addr, account)
+}
+
+func (bm *BlockManager) GetAddrState(addr []byte) *AddressState {
+	addrState := bm.addrStateStore.Get(addr)
+	if addrState == nil {
+		addrState = bm.WatchAddr(addr)
+	}
+
+	return addrState
+}
+
 func (bm *BlockManager) BlockChain() *BlockChain {
 	return bm.bc
 }
@@ -165,7 +187,7 @@ func (bm *BlockManager) ProcessBlock(block *Block) error {
 		*/
 
 		// Broadcast the valid block back to the wire
-		bm.Speaker.Broadcast(ethwire.MsgBlockTy, []interface{}{block.Value().Val})
+		//bm.Speaker.Broadcast(ethwire.MsgBlockTy, []interface{}{block.Value().Val})
 
 		// If there's a block processor present, pass in the block for further
 		// processing