Refactored block & Transaction

* Includes new rlp decoder

3 files changed, 249 insertions, 385 deletions

diff --git a/core/types/block.go b/core/types/block.go
index 2d889f35f..b0fcbdd9b 100644
--- a/core/types/block.go
+++ b/core/types/block.go
@@ -9,408 +9,252 @@ import (
 
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/ethutil"
+	"github.com/ethereum/go-ethereum/rlp"
 	"github.com/ethereum/go-ethereum/state"
 	"github.com/ethereum/go-ethereum/trie"
 )
 
-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 {
+type Header struct {
 	// Hash to the previous block
-	PrevHash ethutil.Bytes
+	ParentHash ethutil.Bytes
 	// Uncles of this block
-	Uncles   Blocks
-	UncleSha []byte
+	UncleHash []byte
 	// The coin base address
 	Coinbase []byte
 	// Block Trie state
-	//state *ethutil.Trie
-	state *state.StateDB
+	Root []byte
+	// Tx sha
+	TxHash []byte
+	// Receipt sha
+	ReceiptHash []byte
+	// Bloom
+	Bloom []byte
 	// Difficulty for the current block
 	Difficulty *big.Int
-	// Creation time
-	Time int64
 	// The block number
 	Number *big.Int
 	// Gas limit
 	GasLimit *big.Int
 	// Gas used
 	GasUsed *big.Int
+	// Creation time
+	Time uint64
 	// Extra data
 	Extra string
 	// Block Nonce for verification
 	Nonce ethutil.Bytes
-	// List of transactions and/or contracts
-	transactions      Transactions
-	receipts          Receipts
-	TxSha, ReceiptSha []byte
-	LogsBloom         []byte
-
-	Reward *big.Int
 }
 
-func NewBlockFromBytes(raw []byte) *Block {
-	block := &Block{}
-	block.RlpDecode(raw)
+func (self *Header) rlpData(withNonce bool) []interface{} {
+	fields := []interface{}{self.ParentHash, self.UncleHash, self.Coinbase, self.Root, self.TxHash, self.ReceiptHash, self.Bloom, self.Difficulty, self.Number, self.GasLimit, self.GasUsed, self.Time, self.Extra}
+	if withNonce {
+		fields = append(fields, self.Nonce)
+	}
 
-	return block
+	return fields
+}
+
+func (self *Header) RlpData() interface{} {
+	return self.rlpData(true)
 }
 
-// New block takes a raw encoded string
-func NewBlockFromRlpValue(rlpValue *ethutil.Value) *Block {
-	block := &Block{}
-	block.RlpValueDecode(rlpValue)
+func (self *Header) Hash() []byte {
+	return crypto.Sha3(ethutil.Encode(self.rlpData(true)))
+}
 
-	return block
+func (self *Header) HashNoNonce() []byte {
+	return crypto.Sha3(ethutil.Encode(self.rlpData(false)))
 }
 
-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(),
+type Block struct {
+	header       *Header
+	uncles       []*Header
+	transactions Transactions
+	Td           *big.Int
+
+	receipts Receipts
+	Reward   *big.Int
+}
+
+func NewBlock(parentHash []byte, coinbase []byte, root []byte, difficulty *big.Int, nonce []byte, extra string) *Block {
+	header := &Header{
+		Root:       root,
+		ParentHash: parentHash,
+		Coinbase:   coinbase,
+		Difficulty: difficulty,
+		Nonce:      nonce,
+		Time:       uint64(time.Now().Unix()),
 		Extra:      extra,
-		UncleSha:   nil,
 		GasUsed:    new(big.Int),
 		GasLimit:   new(big.Int),
 	}
-	block.SetUncles([]*Block{})
 
-	block.state = state.New(trie.New(ethutil.Config.Db, root))
+	block := &Block{header: header, Reward: new(big.Int)}
 
 	return block
 }
 
-// Returns a hash of the block
-func (block *Block) Hash() ethutil.Bytes {
-	return crypto.Sha3(ethutil.NewValue(block.header()).Encode())
-	//return crypto.Sha3(block.Value().Encode())
-}
-
-func (block *Block) HashNoNonce() []byte {
-	return crypto.Sha3(ethutil.Encode(block.miningHeader()))
-}
-
-func (block *Block) State() *state.StateDB {
-	return block.state
-}
-
-func (block *Block) Transactions() Transactions {
-	return block.transactions
+func NewBlockWithHeader(header *Header) *Block {
+	return &Block{header: header}
 }
 
-func (block *Block) CalcGasLimit(parent *Block) *big.Int {
-	if block.Number.Cmp(big.NewInt(0)) == 0 {
-		return ethutil.BigPow(10, 6)
+func (self *Block) DecodeRLP(s *rlp.Stream) error {
+	if _, err := s.List(); err != nil {
+		return err
 	}
 
-	// ((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 _, tx := range self.transactions {
-		if bytes.Compare(tx.Hash(), hash) == 0 {
-			return tx
-		}
+	var header Header
+	if err := s.Decode(&header); err != nil {
+		return err
 	}
 
-	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()
+	var transactions []*Transaction
+	if err := s.Decode(&transactions); err != nil {
+		return err
 	}
 
-	return encR
-}
+	var uncleHeaders []*Header
+	if err := s.Decode(&uncleHeaders); err != nil {
+		return err
+	}
 
-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()
+	var tdBytes []byte
+	if err := s.Decode(&tdBytes); err != nil {
+		// If this block comes from the network that's fine. If loaded from disk it should be there
+		// Blocks don't store their Td when propagated over the network
+	} else {
+		self.Td = ethutil.BigD(tdBytes)
 	}
 
-	return uncles
-}
+	if err := s.ListEnd(); err != nil {
+		return err
+	}
 
-func (block *Block) SetUncles(uncles []*Block) {
-	block.Uncles = uncles
-	block.UncleSha = crypto.Sha3(ethutil.Encode(block.rlpUncles()))
-}
+	self.header = &header
+	self.uncles = uncleHeaders
+	self.transactions = transactions
 
-func (self *Block) SetReceipts(receipts Receipts) {
-	self.receipts = receipts
-	self.ReceiptSha = DeriveSha(receipts)
-	self.LogsBloom = CreateBloom(receipts)
+	return nil
 }
 
-func (self *Block) SetTransactions(txs Transactions) {
-	self.transactions = txs
-	self.TxSha = DeriveSha(txs)
+func (self *Block) Header() *Header {
+	return self.header
 }
 
-func (block *Block) Value() *ethutil.Value {
-	return ethutil.NewValue([]interface{}{block.header(), block.transactions, block.rlpUncles()})
+func (self *Block) Uncles() []*Header {
+	return self.uncles
 }
 
-func (block *Block) RlpEncode() []byte {
-	// Encode a slice interface which contains the header and the list of
-	// transactions.
-	return block.Value().Encode()
+func (self *Block) SetUncles(uncleHeaders []*Header) {
+	self.uncles = uncleHeaders
+	self.header.UncleHash = crypto.Sha3(ethutil.Encode(uncleHeaders))
 }
 
-func (block *Block) RlpDecode(data []byte) {
-	rlpValue := ethutil.NewValueFromBytes(data)
-	block.RlpValueDecode(rlpValue)
+func (self *Block) Transactions() Transactions {
+	return self.transactions
 }
 
-func (block *Block) RlpValueDecode(decoder *ethutil.Value) {
-	block.setHeader(decoder.Get(0))
-
-	// 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.receipts = make([]*Receipt, receipts.Len())
-		txs := decoder.Get(1)
-		block.transactions = make(Transactions, txs.Len())
-		for i := 0; i < txs.Len(); i++ {
-			block.transactions[i] = NewTransactionFromValue(txs.Get(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 (self *Block) Transaction(hash []byte) *Transaction {
+	for _, transaction := range self.transactions {
+		if bytes.Equal(hash, transaction.Hash()) {
+			return transaction
 		}
 	}
-
+	return nil
 }
 
-func (self *Block) setHeader(header *ethutil.Value) {
-	self.PrevHash = header.Get(0).Bytes()
-	self.UncleSha = header.Get(1).Bytes()
-	self.Coinbase = header.Get(2).Bytes()
-	self.state = state.New(trie.New(ethutil.Config.Db, header.Get(3).Val))
-	self.TxSha = header.Get(4).Bytes()
-	self.ReceiptSha = header.Get(5).Bytes()
-	self.LogsBloom = header.Get(6).Bytes()
-	self.Difficulty = header.Get(7).BigInt()
-	self.Number = header.Get(8).BigInt()
-	self.GasLimit = header.Get(9).BigInt()
-	self.GasUsed = header.Get(10).BigInt()
-	self.Time = int64(header.Get(11).BigInt().Uint64())
-	self.Extra = header.Get(12).Str()
-	self.Nonce = header.Get(13).Bytes()
+func (self *Block) SetTransactions(transactions Transactions) {
+	self.transactions = transactions
+	self.header.TxHash = DeriveSha(transactions)
 }
 
-func NewUncleBlockFromValue(header *ethutil.Value) *Block {
-	block := &Block{}
-	block.setHeader(header)
-
-	return block
+func (self *Block) Receipts() Receipts {
+	return self.receipts
 }
 
-func (block *Block) Trie() *trie.Trie {
-	return block.state.Trie
+func (self *Block) SetReceipts(receipts Receipts) {
+	self.receipts = receipts
+	self.header.ReceiptHash = DeriveSha(receipts)
+	self.header.Bloom = CreateBloom(receipts)
 }
 
-func (block *Block) Root() interface{} {
-	return block.state.Root()
+func (self *Block) RlpData() interface{} {
+	return []interface{}{self.header, self.transactions, self.uncles}
+}
+
+func (self *Block) RlpDataForStorage() interface{} {
+	return []interface{}{self.header, self.transactions, self.uncles, self.Td /* TODO receipts */}
+}
+
+// Header accessors (add as you need them)
+func (self *Block) Number() *big.Int          { return self.header.Number }
+func (self *Block) NumberU64() uint64         { return self.header.Number.Uint64() }
+func (self *Block) ParentHash() []byte        { return self.header.ParentHash }
+func (self *Block) Bloom() []byte             { return self.header.Bloom }
+func (self *Block) Coinbase() []byte          { return self.header.Coinbase }
+func (self *Block) Time() int64               { return int64(self.header.Time) }
+func (self *Block) GasLimit() *big.Int        { return self.header.GasLimit }
+func (self *Block) GasUsed() *big.Int         { return self.header.GasUsed }
+func (self *Block) Hash() []byte              { return self.header.Hash() }
+func (self *Block) Trie() *trie.Trie          { return trie.New(ethutil.Config.Db, self.header.Root) }
+func (self *Block) State() *state.StateDB     { return state.New(self.Trie()) }
+func (self *Block) Size() ethutil.StorageSize { return ethutil.StorageSize(len(ethutil.Encode(self))) }
+
+// Implement block.Pow
+func (self *Block) Difficulty() *big.Int { return self.header.Difficulty }
+func (self *Block) N() []byte            { return self.header.Nonce }
+func (self *Block) HashNoNonce() []byte {
+	return crypto.Sha3(ethutil.Encode(self.header.rlpData(false)))
+}
+
+func (self *Block) String() string {
+	return fmt.Sprintf(`BLOCK(%x): Size: %v {
+%v
+%v
+%v
+}
+`, self.header.Hash(), self.Size(), self.header, self.uncles, self.transactions)
+}
+
+func (self *Header) String() string {
+	return fmt.Sprintf(`ParentHash:	    %x
+UncleHash:	    %x
+Coinbase:	    %x
+Root:		    %x
+TxSha		    %x
+ReceiptSha:	    %x
+Bloom:		    %x
+Difficulty:	    %v
+Number:		    %v
+GasLimit:	    %v
+GasUsed:	    %v
+Time:		    %v
+Extra:		    %v
+Nonce:		    %x
+`, self.ParentHash, self.UncleHash, self.Coinbase, self.Root, self.TxHash, self.ReceiptHash, self.Bloom, self.Difficulty, self.Number, self.GasLimit, self.GasUsed, self.Time, self.Extra, self.Nonce)
 }
 
-func (block *Block) Diff() *big.Int {
-	return block.Difficulty
-}
+type Blocks []*Block
 
-func (self *Block) Receipts() []*Receipt {
-	return self.receipts
-}
+type BlockBy func(b1, b2 *Block) bool
 
-func (block *Block) miningHeader() []interface{} {
-	return []interface{}{
-		// Sha of the previous block
-		block.PrevHash,
-		// Sha of uncles
-		block.UncleSha,
-		// Coinbase address
-		block.Coinbase,
-		// root state
-		block.Root(),
-		// tx root
-		block.TxSha,
-		// Sha of tx
-		block.ReceiptSha,
-		// Bloom
-		block.LogsBloom,
-		// Current block Difficulty
-		block.Difficulty,
-		// The block number
-		block.Number,
-		// Block upper gas bound
-		block.GasLimit,
-		// Block gas used
-		block.GasUsed,
-		// Time the block was found?
-		block.Time,
-		// Extra data
-		block.Extra,
+func (self BlockBy) Sort(blocks Blocks) {
+	bs := blockSorter{
+		blocks: blocks,
+		by:     self,
 	}
+	sort.Sort(bs)
 }
 
-func (block *Block) header() []interface{} {
-	return append(block.miningHeader(), block.Nonce)
-}
-
-func (block *Block) String() string {
-	return fmt.Sprintf(`
-	BLOCK(%x): Size: %v
-	PrevHash:   %x
-	UncleSha:   %x
-	Coinbase:   %x
-	Root:       %x
-	TxSha       %x
-	ReceiptSha: %x
-	Bloom:      %x
-	Difficulty: %v
-	Number:     %v
-	MaxLimit:   %v
-	GasUsed:    %v
-	Time:       %v
-	Extra:      %v
-	Nonce:      %x
-	NumTx:      %v
-`,
-		block.Hash(),
-		block.Size(),
-		block.PrevHash,
-		block.UncleSha,
-		block.Coinbase,
-		block.Root(),
-		block.TxSha,
-		block.ReceiptSha,
-		block.LogsBloom,
-		block.Difficulty,
-		block.Number,
-		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()))
+type blockSorter struct {
+	blocks Blocks
+	by     func(b1, b2 *Block) bool
 }
 
-// Implement RlpEncodable
-func (self *Block) RlpData() interface{} {
-	return []interface{}{self.header(), self.transactions, self.rlpUncles()}
+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]) }
 
-// Implement pow.Block
-func (self *Block) N() []byte { return self.Nonce }
+func Number(b1, b2 *Block) bool { return b1.Header().Number.Cmp(b2.Header().Number) < 0 }
diff --git a/core/types/block_test.go b/core/types/block_test.go
new file mode 100644
index 000000000..c85708975
--- /dev/null
+++ b/core/types/block_test.go
@@ -0,0 +1,23 @@
+package types
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/ethdb"
+	"github.com/ethereum/go-ethereum/ethutil"
+	"github.com/ethereum/go-ethereum/rlp"
+)
+
+func init() {
+	ethutil.ReadConfig(".ethtest", "/tmp/ethtest", "")
+	ethutil.Config.Db, _ = ethdb.NewMemDatabase()
+}
+
+func TestNewBlock(t *testing.T) {
+	block := GenesisBlock()
+	data := ethutil.Encode(block)
+
+	var genesis Block
+	err := rlp.Decode(bytes.NewReader(data), &genesis)
+}
diff --git a/core/types/transaction.go b/core/types/transaction.go
index 3a87f7844..c2f7df7a7 100644
--- a/core/types/transaction.go
+++ b/core/types/transaction.go
@@ -1,11 +1,13 @@
 package types
 
 import (
+	"bytes"
 	"fmt"
 	"math/big"
 
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/ethutil"
+	"github.com/ethereum/go-ethereum/rlp"
 	"github.com/obscuren/secp256k1-go"
 )
 
@@ -14,22 +16,22 @@ func IsContractAddr(addr []byte) bool {
 }
 
 type Transaction struct {
-	nonce     uint64
-	recipient []byte
-	value     *big.Int
-	gas       *big.Int
-	gasPrice  *big.Int
-	data      []byte
-	v         byte
-	r, s      []byte
+	AccountNonce uint64
+	Recipient    []byte
+	Amount       *big.Int
+	GasAmount    *big.Int
+	Price        *big.Int
+	Payload      []byte
+	V            uint64
+	R, S         []byte
 }
 
-func NewContractCreationTx(value, gas, gasPrice *big.Int, script []byte) *Transaction {
-	return &Transaction{recipient: nil, value: value, gas: gas, gasPrice: gasPrice, data: script}
+func NewContractCreationTx(Amount, gasAmount, price *big.Int, data []byte) *Transaction {
+	return NewTransactionMessage(nil, Amount, gasAmount, price, data)
 }
 
-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 NewTransactionMessage(to []byte, Amount, gasAmount, price *big.Int, data []byte) *Transaction {
+	return &Transaction{Recipient: to, Amount: Amount, Price: price, GasAmount: gasAmount, Payload: data}
 }
 
 func NewTransactionFromBytes(data []byte) *Transaction {
@@ -39,7 +41,7 @@ func NewTransactionFromBytes(data []byte) *Transaction {
 	return tx
 }
 
-func NewTransactionFromValue(val *ethutil.Value) *Transaction {
+func NewTransactionFromAmount(val *ethutil.Value) *Transaction {
 	tx := &Transaction{}
 	tx.RlpValueDecode(val)
 
@@ -47,33 +49,33 @@ func NewTransactionFromValue(val *ethutil.Value) *Transaction {
 }
 
 func (tx *Transaction) Hash() []byte {
-	data := []interface{}{tx.nonce, tx.gasPrice, tx.gas, tx.recipient, tx.value, tx.data}
+	data := []interface{}{tx.AccountNonce, tx.Price, tx.GasAmount, tx.Recipient, tx.Amount, tx.Payload}
 
-	return crypto.Sha3(ethutil.NewValue(data).Encode())
+	return crypto.Sha3(ethutil.Encode(data))
 }
 
 func (self *Transaction) Data() []byte {
-	return self.data
+	return self.Payload
 }
 
 func (self *Transaction) Gas() *big.Int {
-	return self.gas
+	return self.GasAmount
 }
 
 func (self *Transaction) GasPrice() *big.Int {
-	return self.gasPrice
+	return self.Price
 }
 
 func (self *Transaction) Value() *big.Int {
-	return self.value
+	return self.Amount
 }
 
 func (self *Transaction) Nonce() uint64 {
-	return self.nonce
+	return self.AccountNonce
 }
 
-func (self *Transaction) SetNonce(nonce uint64) {
-	self.nonce = nonce
+func (self *Transaction) SetNonce(AccountNonce uint64) {
+	self.AccountNonce = AccountNonce
 }
 
 func (self *Transaction) From() []byte {
@@ -81,13 +83,13 @@ func (self *Transaction) From() []byte {
 }
 
 func (self *Transaction) To() []byte {
-	return self.recipient
+	return self.Recipient
 }
 
 func (tx *Transaction) Curve() (v byte, r []byte, s []byte) {
-	v = tx.v
-	r = ethutil.LeftPadBytes(tx.r, 32)
-	s = ethutil.LeftPadBytes(tx.s, 32)
+	v = byte(tx.V)
+	r = ethutil.LeftPadBytes(tx.R, 32)
+	s = ethutil.LeftPadBytes(tx.S, 32)
 
 	return
 }
@@ -130,42 +132,37 @@ 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
+	tx.R = sig[:32]
+	tx.S = sig[32:64]
+	tx.V = uint64(sig[64] + 27)
 
 	return nil
 }
 
 func (tx *Transaction) RlpData() interface{} {
-	data := []interface{}{tx.nonce, tx.gasPrice, tx.gas, tx.recipient, tx.value, tx.data}
+	data := []interface{}{tx.AccountNonce, tx.Price, tx.GasAmount, tx.Recipient, tx.Amount, tx.Payload}
 
-	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())
+	return append(data, tx.V, new(big.Int).SetBytes(tx.R).Bytes(), new(big.Int).SetBytes(tx.S).Bytes())
 }
 
 func (tx *Transaction) RlpEncode() []byte {
-	return tx.RlpValue().Encode()
+	return ethutil.Encode(tx)
 }
 
 func (tx *Transaction) RlpDecode(data []byte) {
-	tx.RlpValueDecode(ethutil.NewValueFromBytes(data))
+	rlp.Decode(bytes.NewReader(data), tx)
 }
 
 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()
+	tx.AccountNonce = decoder.Get(0).Uint()
+	tx.Price = decoder.Get(1).BigInt()
+	tx.GasAmount = decoder.Get(2).BigInt()
+	tx.Recipient = decoder.Get(3).Bytes()
+	tx.Amount = decoder.Get(4).BigInt()
+	tx.Payload = decoder.Get(5).Bytes()
+	tx.V = decoder.Get(6).Uint()
+	tx.R = decoder.Get(7).Bytes()
+	tx.S = decoder.Get(8).Bytes()
 }
 
 func (tx *Transaction) String() string {
@@ -174,10 +171,10 @@ func (tx *Transaction) String() string {
 	Contract: %v
 	From:     %x
 	To:       %x
-	Nonce:    %v
-	GasPrice: %v
-	Gas:      %v
-	Value:    %v
+	AccountNonce:    %v
+	GasAmountPrice: %v
+	GasAmount:      %v
+	Amount:    %v
 	Data:     0x%x
 	V:        0x%x
 	R:        0x%x
@@ -185,17 +182,17 @@ func (tx *Transaction) String() string {
 	Hex:      %x
 	`,
 		tx.Hash(),
-		len(tx.recipient) == 0,
+		len(tx.Recipient) == 0,
 		tx.From(),
-		tx.recipient,
-		tx.nonce,
-		tx.gasPrice,
-		tx.gas,
-		tx.value,
-		tx.data,
-		tx.v,
-		tx.r,
-		tx.s,
+		tx.Recipient,
+		tx.AccountNonce,
+		tx.Price,
+		tx.GasAmount,
+		tx.Amount,
+		tx.Payload,
+		tx.V,
+		tx.R,
+		tx.S,
 		ethutil.Encode(tx),
 	)
 }
@@ -220,5 +217,5 @@ func (s Transactions) GetRlp(i int) []byte { return ethutil.Rlp(s[i]) }
 type TxByNonce struct{ Transactions }
 
 func (s TxByNonce) Less(i, j int) bool {
-	return s.Transactions[i].nonce < s.Transactions[j].nonce
+	return s.Transactions[i].AccountNonce < s.Transactions[j].AccountNonce
 }