Merge pull request #1923 from karalabe/cleanup-receipt-data-access

core, eth, miner, xeth: clean up tx/receipt db accessors

Author: obscuren

core/block_validator_test.go

@@ -81,7 +81,7 @@ func TestPutReceipt(t *testing.T) {
 		Index:       0,
 	}}
 
-	PutReceipts(db, types.Receipts{receipt})
+	WriteReceipts(db, types.Receipts{receipt})
 	receipt = GetReceipt(db, common.Hash{})
 	if receipt == nil {
 		t.Error("expected to get 1 receipt, got none.")

core/blockchain.go

@@ -972,7 +972,7 @@ func (self *BlockChain) InsertReceiptChain(blockChain types.Blocks, receiptChain
 				glog.Fatal(errs[index])
 				return
 			}
-			if err := PutBlockReceipts(self.chainDb, block.Hash(), receipts); err != nil {
+			if err := WriteBlockReceipts(self.chainDb, block.Hash(), receipts); err != nil {
 				errs[index] = fmt.Errorf("failed to write block receipts: %v", err)
 				atomic.AddInt32(&failed, 1)
 				glog.Fatal(errs[index])
@@ -1182,7 +1182,7 @@ func (self *BlockChain) InsertChain(chain types.Blocks) (int, error) {
 		// coalesce logs for later processing
 		coalescedLogs = append(coalescedLogs, logs...)
 
-		if err := PutBlockReceipts(self.chainDb, block.Hash(), receipts); err != nil {
+		if err := WriteBlockReceipts(self.chainDb, block.Hash(), receipts); err != nil {
 			return i, err
 		}
 
@@ -1201,11 +1201,11 @@ func (self *BlockChain) InsertChain(chain types.Blocks) (int, error) {
 			events = append(events, ChainEvent{block, block.Hash(), logs})
 
 			// This puts transactions in a extra db for rpc
-			if err := PutTransactions(self.chainDb, block, block.Transactions()); err != nil {
+			if err := WriteTransactions(self.chainDb, block); err != nil {
 				return i, err
 			}
 			// store the receipts
-			if err := PutReceipts(self.chainDb, receipts); err != nil {
+			if err := WriteReceipts(self.chainDb, receipts); err != nil {
 				return i, err
 			}
 			// Write map map bloom filters
@@ -1294,12 +1294,12 @@ func (self *BlockChain) reorg(oldBlock, newBlock *types.Block) error {
 		// insert the block in the canonical way, re-writing history
 		self.insert(block)
 		// write canonical receipts and transactions
-		if err := PutTransactions(self.chainDb, block, block.Transactions()); err != nil {
+		if err := WriteTransactions(self.chainDb, block); err != nil {
 			return err
 		}
 		receipts := GetBlockReceipts(self.chainDb, block.Hash())
 		// write receipts
-		if err := PutReceipts(self.chainDb, receipts); err != nil {
+		if err := WriteReceipts(self.chainDb, receipts); err != nil {
 			return err
 		}
 		// Write map map bloom filters

core/blockchain_test.go

@@ -937,16 +937,16 @@ func TestChainTxReorgs(t *testing.T) {
 
 	// removed tx
 	for i, tx := range (types.Transactions{pastDrop, freshDrop}) {
-		if GetTransaction(db, tx.Hash()) != nil {
-			t.Errorf("drop %d: tx found while shouldn't have been", i)
+		if txn, _, _, _ := GetTransaction(db, tx.Hash()); txn != nil {
+			t.Errorf("drop %d: tx %v found while shouldn't have been", i, txn)
 		}
 		if GetReceipt(db, tx.Hash()) != nil {
 			t.Errorf("drop %d: receipt found while shouldn't have been", i)
 		}
 	}
 	// added tx
 	for i, tx := range (types.Transactions{pastAdd, freshAdd, futureAdd}) {
-		if GetTransaction(db, tx.Hash()) == nil {
+		if txn, _, _, _ := GetTransaction(db, tx.Hash()); txn == nil {
 			t.Errorf("add %d: expected tx to be found", i)
 		}
 		if GetReceipt(db, tx.Hash()) == nil {
@@ -955,7 +955,7 @@ func TestChainTxReorgs(t *testing.T) {
 	}
 	// shared tx
 	for i, tx := range (types.Transactions{postponed, swapped}) {
-		if GetTransaction(db, tx.Hash()) == nil {
+		if txn, _, _, _ := GetTransaction(db, tx.Hash()); txn == nil {
 			t.Errorf("share %d: expected tx to be found", i)
 		}
 		if GetReceipt(db, tx.Hash()) == nil {

core/chain_util.go renamed to core/database_util.go

@@ -43,11 +43,15 @@ var (
 	bodySuffix   = []byte("-body")
 	tdSuffix     = []byte("-td")
 
-	ExpDiffPeriod = big.NewInt(100000)
-	blockHashPre  = []byte("block-hash-") // [deprecated by eth/63]
+	txMetaSuffix        = []byte{0x01}
+	receiptsPrefix      = []byte("receipts-")
+	blockReceiptsPrefix = []byte("receipts-block-")
 
 	mipmapPre    = []byte("mipmap-log-bloom-")
 	MIPMapLevels = []uint64{1000000, 500000, 100000, 50000, 1000}
+
+	ExpDiffPeriod   = big.NewInt(100000)
+	blockHashPrefix = []byte("block-hash-") // [deprecated by the header/block split, remove eventually]
 )
 
 // CalcDifficulty is the difficulty adjustment algorithm. It returns
@@ -234,6 +238,67 @@ func GetBlock(db ethdb.Database, hash common.Hash) *types.Block {
 	return types.NewBlockWithHeader(header).WithBody(body.Transactions, body.Uncles)
 }
 
+// GetBlockReceipts retrieves the receipts generated by the transactions included
+// in a block given by its hash.
+func GetBlockReceipts(db ethdb.Database, hash common.Hash) types.Receipts {
+	data, _ := db.Get(append(blockReceiptsPrefix, hash[:]...))
+	if len(data) == 0 {
+		return nil
+	}
+	storageReceipts := []*types.ReceiptForStorage{}
+	if err := rlp.DecodeBytes(data, &storageReceipts); err != nil {
+		glog.V(logger.Error).Infof("invalid receipt array RLP for hash %x: %v", hash, err)
+		return nil
+	}
+	receipts := make(types.Receipts, len(storageReceipts))
+	for i, receipt := range storageReceipts {
+		receipts[i] = (*types.Receipt)(receipt)
+	}
+	return receipts
+}
+
+// GetTransaction retrieves a specific transaction from the database, along with
+// its added positional metadata.
+func GetTransaction(db ethdb.Database, hash common.Hash) (*types.Transaction, common.Hash, uint64, uint64) {
+	// Retrieve the transaction itself from the database
+	data, _ := db.Get(hash.Bytes())
+	if len(data) == 0 {
+		return nil, common.Hash{}, 0, 0
+	}
+	var tx types.Transaction
+	if err := rlp.DecodeBytes(data, &tx); err != nil {
+		return nil, common.Hash{}, 0, 0
+	}
+	// Retrieve the blockchain positional metadata
+	data, _ = db.Get(append(hash.Bytes(), txMetaSuffix...))
+	if len(data) == 0 {
+		return nil, common.Hash{}, 0, 0
+	}
+	var meta struct {
+		BlockHash  common.Hash
+		BlockIndex uint64
+		Index      uint64
+	}
+	if err := rlp.DecodeBytes(data, &meta); err != nil {
+		return nil, common.Hash{}, 0, 0
+	}
+	return &tx, meta.BlockHash, meta.BlockIndex, meta.Index
+}
+
+// GetReceipt returns a receipt by hash
+func GetReceipt(db ethdb.Database, txHash common.Hash) *types.Receipt {
+	data, _ := db.Get(append(receiptsPrefix, txHash[:]...))
+	if len(data) == 0 {
+		return nil
+	}
+	var receipt types.ReceiptForStorage
+	err := rlp.DecodeBytes(data, &receipt)
+	if err != nil {
+		glog.V(logger.Core).Infoln("GetReceipt err:", err)
+	}
+	return (*types.Receipt)(&receipt)
+}
+
 // WriteCanonicalHash stores the canonical hash for the given block number.
 func WriteCanonicalHash(db ethdb.Database, hash common.Hash, number uint64) error {
 	key := append(blockNumPrefix, big.NewInt(int64(number)).Bytes()...)
@@ -329,6 +394,94 @@ func WriteBlock(db ethdb.Database, block *types.Block) error {
 	return nil
 }
 
+// WriteBlockReceipts stores all the transaction receipts belonging to a block
+// as a single receipt slice. This is used during chain reorganisations for
+// rescheduling dropped transactions.
+func WriteBlockReceipts(db ethdb.Database, hash common.Hash, receipts types.Receipts) error {
+	// Convert the receipts into their storage form and serialize them
+	storageReceipts := make([]*types.ReceiptForStorage, len(receipts))
+	for i, receipt := range receipts {
+		storageReceipts[i] = (*types.ReceiptForStorage)(receipt)
+	}
+	bytes, err := rlp.EncodeToBytes(storageReceipts)
+	if err != nil {
+		return err
+	}
+	// Store the flattened receipt slice
+	if err := db.Put(append(blockReceiptsPrefix, hash.Bytes()...), bytes); err != nil {
+		glog.Fatalf("failed to store block receipts into database: %v", err)
+		return err
+	}
+	glog.V(logger.Debug).Infof("stored block receipts [%x…]", hash.Bytes()[:4])
+	return nil
+}
+
+// WriteTransactions stores the transactions associated with a specific block
+// into the given database. Beside writing the transaction, the function also
+// stores a metadata entry along with the transaction, detailing the position
+// of this within the blockchain.
+func WriteTransactions(db ethdb.Database, block *types.Block) error {
+	batch := db.NewBatch()
+
+	// Iterate over each transaction and encode it with its metadata
+	for i, tx := range block.Transactions() {
+		// Encode and queue up the transaction for storage
+		data, err := rlp.EncodeToBytes(tx)
+		if err != nil {
+			return err
+		}
+		if err := batch.Put(tx.Hash().Bytes(), data); err != nil {
+			return err
+		}
+		// Encode and queue up the transaction metadata for storage
+		meta := struct {
+			BlockHash  common.Hash
+			BlockIndex uint64
+			Index      uint64
+		}{
+			BlockHash:  block.Hash(),
+			BlockIndex: block.NumberU64(),
+			Index:      uint64(i),
+		}
+		data, err = rlp.EncodeToBytes(meta)
+		if err != nil {
+			return err
+		}
+		if err := batch.Put(append(tx.Hash().Bytes(), txMetaSuffix...), data); err != nil {
+			return err
+		}
+	}
+	// Write the scheduled data into the database
+	if err := batch.Write(); err != nil {
+		glog.Fatalf("failed to store transactions into database: %v", err)
+		return err
+	}
+	return nil
+}
+
+// WriteReceipts stores a batch of transaction receipts into the database.
+func WriteReceipts(db ethdb.Database, receipts types.Receipts) error {
+	batch := db.NewBatch()
+
+	// Iterate over all the receipts and queue them for database injection
+	for _, receipt := range receipts {
+		storageReceipt := (*types.ReceiptForStorage)(receipt)
+		data, err := rlp.EncodeToBytes(storageReceipt)
+		if err != nil {
+			return err
+		}
+		if err := batch.Put(append(receiptsPrefix, receipt.TxHash.Bytes()...), data); err != nil {
+			return err
+		}
+	}
+	// Write the scheduled data into the database
+	if err := batch.Write(); err != nil {
+		glog.Fatalf("failed to store receipts into database: %v", err)
+		return err
+	}
+	return nil
+}
+
 // DeleteCanonicalHash removes the number to hash canonical mapping.
 func DeleteCanonicalHash(db ethdb.Database, number uint64) {
 	db.Delete(append(blockNumPrefix, big.NewInt(int64(number)).Bytes()...))
@@ -351,18 +504,35 @@ func DeleteTd(db ethdb.Database, hash common.Hash) {
 
 // DeleteBlock removes all block data associated with a hash.
 func DeleteBlock(db ethdb.Database, hash common.Hash) {
+	DeleteBlockReceipts(db, hash)
 	DeleteHeader(db, hash)
 	DeleteBody(db, hash)
 	DeleteTd(db, hash)
 }
 
-// [deprecated by eth/63]
+// DeleteBlockReceipts removes all receipt data associated with a block hash.
+func DeleteBlockReceipts(db ethdb.Database, hash common.Hash) {
+	db.Delete(append(blockReceiptsPrefix, hash.Bytes()...))
+}
+
+// DeleteTransaction removes all transaction data associated with a hash.
+func DeleteTransaction(db ethdb.Database, hash common.Hash) {
+	db.Delete(hash.Bytes())
+	db.Delete(append(hash.Bytes(), txMetaSuffix...))
+}
+
+// DeleteReceipt removes all receipt data associated with a transaction hash.
+func DeleteReceipt(db ethdb.Database, hash common.Hash) {
+	db.Delete(append(receiptsPrefix, hash.Bytes()...))
+}
+
+// [deprecated by the header/block split, remove eventually]
 // GetBlockByHashOld returns the old combined block corresponding to the hash
 // or nil if not found. This method is only used by the upgrade mechanism to
 // access the old combined block representation. It will be dropped after the
 // network transitions to eth/63.
 func GetBlockByHashOld(db ethdb.Database, hash common.Hash) *types.Block {
-	data, _ := db.Get(append(blockHashPre, hash[:]...))
+	data, _ := db.Get(append(blockHashPrefix, hash[:]...))
 	if len(data) == 0 {
 		return nil
 	}