Skip to content

Commit

Permalink
rawdb deprecated methods with Database interface (erigontech#1854)
Browse files Browse the repository at this point in the history
  • Loading branch information
@AskAlexSharov
AskAlexSharov authored May 1, 2021
1 parent ad59865 commit aacc457
Show file tree
Hide file tree
Showing 65 changed files with 790 additions and 537 deletions.
14 changes: 7 additions & 7 deletions accounts/abi/bind/backends/simulated.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -268,7 +268,7 @@ func (b *SimulatedBackend) TransactionByHash(ctx context.Context, txHash common.
if tx != nil {
return tx, true, nil
}
tx, _, _, _ = rawdb.ReadTransaction(b.database, txHash)
tx, _, _, _ = rawdb.ReadTransactionDeprecated(b.database, txHash)
if tx != nil {
return tx, false, nil
}
Expand All @@ -284,7 +284,7 @@ func (b *SimulatedBackend) BlockByHash(ctx context.Context, hash common.Hash) (*
return b.pendingBlock, nil
}

block, err := rawdb.ReadBlockByHash(b.database, hash)
block, err := rawdb.ReadBlockByHashDeprecated(b.database, hash)
if err != nil {
return nil, err
}
Expand Down Expand Up @@ -315,7 +315,7 @@ func (b *SimulatedBackend) blockByNumberNoLock(_ context.Context, number *big.In
if err != nil {
return nil, err
}
block := rawdb.ReadBlock(b.database, hash, number.Uint64())
block := rawdb.ReadBlockDeprecated(b.database, hash, number.Uint64())
if block == nil {
return nil, errBlockDoesNotExist
}
Expand Down Expand Up @@ -370,7 +370,7 @@ func (b *SimulatedBackend) TransactionCount(ctx context.Context, blockHash commo
return uint(b.pendingBlock.Transactions().Len()), nil
}

block, err := rawdb.ReadBlockByHash(b.database, blockHash)
block, err := rawdb.ReadBlockByHashDeprecated(b.database, blockHash)
if err != nil {
return 0, err
}
Expand All @@ -395,7 +395,7 @@ func (b *SimulatedBackend) TransactionInBlock(ctx context.Context, blockHash com
return transactions[index], nil
}

block, err := rawdb.ReadBlockByHash(b.database, blockHash)
block, err := rawdb.ReadBlockByHashDeprecated(b.database, blockHash)
if err != nil {
return nil, err
}
Expand Down Expand Up @@ -830,15 +830,15 @@ func (fb *filterBackend) GetReceipts(ctx context.Context, hash common.Hash) (typ
if number == nil {
return nil, nil
}
return rawdb.ReadReceipts(fb.db, hash, *number), nil
return rawdb.ReadReceiptsDeprecated(fb.db, hash, *number), nil
}

func (fb *filterBackend) GetLogs(ctx context.Context, hash common.Hash) ([][]*types.Log, error) {
number := rawdb.ReadHeaderNumber(fb.db, hash)
if number == nil {
return nil, nil
}
receipts := rawdb.ReadReceipts(fb.db, hash, *number)
receipts := rawdb.ReadReceiptsDeprecated(fb.db, hash, *number)
if receipts == nil {
return nil, nil
}
Expand Down
2 changes: 1 addition & 1 deletion accounts/abi/bind/backends/simulated_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -142,7 +142,7 @@ func TestNewSimulatedBackend(t *testing.T) {
}
defer tx.Rollback()

statedb := state.New(state.NewPlainDBState(tx, rawdb.ReadCurrentBlock(sim.database).NumberU64()))
statedb := state.New(state.NewPlainDBState(tx, rawdb.ReadCurrentBlockDeprecated(sim.database).NumberU64()))
bal := statedb.GetBalance(testAddr)
if !bal.Eq(expectedBal) {
t.Errorf("expected balance for test address not received. expected: %v actual: %v", expectedBal, bal)
Expand Down
202 changes: 97 additions & 105 deletions cmd/hack/hack.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -701,18 +701,23 @@ func printCurrentBlockNumber(chaindata string) {
}

func printTxHashes() {
ethDb := ethdb.MustOpen(paths.DefaultDataDir() + "/geth/chaindata")
defer ethDb.Close()
for b := uint64(0); b < uint64(100000); b++ {
hash, err := rawdb.ReadCanonicalHash(ethDb, b)
tool.Check(err)
block := rawdb.ReadBlock(ethDb, hash, b)
if block == nil {
break
}
for _, tx := range block.Transactions() {
fmt.Printf("%x\n", tx.Hash())
db := ethdb.MustOpen(paths.DefaultDataDir() + "/geth/chaindata").RwKV()
defer db.Close()
if err := db.View(context.Background(), func(tx ethdb.Tx) error {
for b := uint64(0); b < uint64(100000); b++ {
hash, err := rawdb.ReadCanonicalHash(tx, b)
tool.Check(err)
block := rawdb.ReadBlock(tx, hash, b)
if block == nil {
break
}
for _, tx := range block.Transactions() {
fmt.Printf("%x\n", tx.Hash())
}
}
return nil
}); err != nil {
panic(err)
}
}

Expand Down Expand Up @@ -802,21 +807,6 @@ func readAccount(chaindata string, account common.Address) error {
return nil
}

func fixAccount(chaindata string, addrHash common.Hash, storageRoot common.Hash) {
ethDb := ethdb.MustOpen(chaindata)
defer ethDb.Close()
var a accounts.Account
if ok, err := rawdb.ReadAccount(ethDb, addrHash, &a); err != nil {
panic(err)
} else if !ok {
panic("acc not found")
}
a.Root = storageRoot
if err := rawdb.WriteAccount(ethDb, addrHash, a); err != nil {
panic(err)
}
}

func nextIncarnation(chaindata string, addrHash common.Hash) {
ethDb := ethdb.MustOpen(chaindata)
defer ethDb.Close()
Expand Down Expand Up @@ -934,15 +924,20 @@ func ValidateTxLookups2(chaindata string) {
}

func validateTxLookups2(db ethdb.Database, startBlock uint64, interruptCh chan bool) {
tx, err := db.(ethdb.HasRwKV).RwKV().BeginRo(context.Background())
if err != nil {
panic(err)
}
defer tx.Rollback()
blockNum := startBlock
iterations := 0
var interrupt bool
// Validation Process
blockBytes := big.NewInt(0)
for !interrupt {
blockHash, err := rawdb.ReadCanonicalHash(db, blockNum)
blockHash, err := rawdb.ReadCanonicalHash(tx, blockNum)
tool.Check(err)
body := rawdb.ReadBody(db, blockHash, blockNum)
body := rawdb.ReadBody(tx, blockHash, blockNum)

if body == nil {
break
Expand All @@ -956,8 +951,8 @@ func validateTxLookups2(db ethdb.Database, startBlock uint64, interruptCh chan b
blockBytes.SetUint64(blockNum)
bn := blockBytes.Bytes()

for _, tx := range body.Transactions {
val, err := db.Get(dbutils.TxLookupPrefix, tx.Hash().Bytes())
for _, txn := range body.Transactions {
val, err := tx.GetOne(dbutils.TxLookupPrefix, txn.Hash().Bytes())
iterations++
if iterations%100000 == 0 {
log.Info("Validated", "entries", iterations, "number", blockNum)
Expand Down Expand Up @@ -1053,20 +1048,20 @@ func regenerate(chaindata string) error {
defer tx.Rollback()

tool.Check(stagedsync.ResetIH(tx))
to, err := stages.GetStageProgress(ethdb.NewRoTxDb(tx), stages.HashState)
to, err := stages.GetStageProgress(tx, stages.HashState)
if err != nil {
return err
}
hash, err := rawdb.ReadCanonicalHash(ethdb.NewRoTxDb(tx), to)
hash, err := rawdb.ReadCanonicalHash(tx, to)
if err != nil {
return err
}
syncHeadHeader := rawdb.ReadHeader(ethdb.NewRoTxDb(tx), hash, to)
syncHeadHeader := rawdb.ReadHeader(tx, hash, to)
expectedRootHash := syncHeadHeader.Root
_, err = stagedsync.RegenerateIntermediateHashes("", tx, stagedsync.StageTrieCfg(true, true, ""), expectedRootHash, nil)
tool.Check(err)
log.Info("Regeneration ended")
return nil
return tx.Commit()
}

func testGetProof(chaindata string, address common.Address, rewind int, regen bool) error {
Expand Down Expand Up @@ -1438,87 +1433,87 @@ func mint(chaindata string, block uint64) error {
defer f.Close()
w := bufio.NewWriter(f)
defer w.Flush()
db := ethdb.MustOpen(chaindata)
db := ethdb.MustOpen(chaindata).RwKV()
defer db.Close()
tx, err := db.BeginRw(context.Background())
if err != nil {
return err
}
defer tx.Rollback()
//chiTokenAddr = common.HexToAddress("0x0000000000004946c0e9F43F4Dee607b0eF1fA1c")
//mintFuncPrefix = common.FromHex("0xa0712d68")
var gwei uint256.Int
gwei.SetUint64(1000000000)
blockEncoded := dbutils.EncodeBlockNumber(block)
canonical := make(map[common.Hash]struct{})
if err1 := db.RwKV().View(context.Background(), func(tx ethdb.Tx) error {
c, err := tx.Cursor(dbutils.HeaderCanonicalBucket)
c, err := tx.Cursor(dbutils.HeaderCanonicalBucket)
if err != nil {
return err
}

// This is a mapping of contractAddress + incarnation => CodeHash
for k, v, err := c.Seek(blockEncoded); k != nil; k, v, err = c.Next() {
if err != nil {
return err
}

// This is a mapping of contractAddress + incarnation => CodeHash
for k, v, err := c.Seek(blockEncoded); k != nil; k, v, err = c.Next() {
if err != nil {
return err
}
// Skip non relevant records
canonical[common.BytesToHash(v)] = struct{}{}
if len(canonical)%100_000 == 0 {
log.Info("Read canonical hashes", "count", len(canonical))
}
// Skip non relevant records
canonical[common.BytesToHash(v)] = struct{}{}
if len(canonical)%100_000 == 0 {
log.Info("Read canonical hashes", "count", len(canonical))
}
log.Info("Read canonical hashes", "count", len(canonical))
c, err = tx.Cursor(dbutils.BlockBodyPrefix)
}
log.Info("Read canonical hashes", "count", len(canonical))
c, err = tx.Cursor(dbutils.BlockBodyPrefix)
if err != nil {
return err
}
var prevBlock uint64
var burntGas uint64
for k, _, err := c.Seek(blockEncoded); k != nil; k, _, err = c.Next() {
if err != nil {
return err
}
var prevBlock uint64
var burntGas uint64
for k, _, err := c.Seek(blockEncoded); k != nil; k, _, err = c.Next() {
if err != nil {
return err
}
blockNumber := binary.BigEndian.Uint64(k[:8])
blockHash := common.BytesToHash(k[8:])
if _, isCanonical := canonical[blockHash]; !isCanonical {
continue
}
if blockNumber != prevBlock && blockNumber != prevBlock+1 {
fmt.Printf("Gap [%d-%d]\n", prevBlock, blockNumber-1)
}
prevBlock = blockNumber
body := rawdb.ReadBody(db, blockHash, blockNumber)
header := rawdb.ReadHeader(db, blockHash, blockNumber)
senders, errSenders := rawdb.ReadSenders(db, blockHash, blockNumber)
if errSenders != nil {
return errSenders
}
var ethSpent uint256.Int
var ethSpentTotal uint256.Int
var totalGas uint256.Int
count := 0
for i, tx := range body.Transactions {
ethSpent.SetUint64(tx.GetGas())
totalGas.Add(&totalGas, &ethSpent)
if senders[i] == header.Coinbase {
continue // Mining pool sending payout potentially with abnormally low fee, skip
}
ethSpent.Mul(&ethSpent, tx.GetPrice())
ethSpentTotal.Add(&ethSpentTotal, &ethSpent)
count++
}
if count > 0 {
ethSpentTotal.Div(&ethSpentTotal, &totalGas)
ethSpentTotal.Div(&ethSpentTotal, &gwei)
gasPrice := ethSpentTotal.Uint64()
burntGas += header.GasUsed
fmt.Fprintf(w, "%d, %d\n", burntGas, gasPrice)
}
if blockNumber%100_000 == 0 {
log.Info("Processed", "blocks", blockNumber)
blockNumber := binary.BigEndian.Uint64(k[:8])
blockHash := common.BytesToHash(k[8:])
if _, isCanonical := canonical[blockHash]; !isCanonical {
continue
}
if blockNumber != prevBlock && blockNumber != prevBlock+1 {
fmt.Printf("Gap [%d-%d]\n", prevBlock, blockNumber-1)
}
prevBlock = blockNumber
body := rawdb.ReadBody(tx, blockHash, blockNumber)
header := rawdb.ReadHeader(tx, blockHash, blockNumber)
senders, errSenders := rawdb.ReadSenders(tx, blockHash, blockNumber)
if errSenders != nil {
return errSenders
}
var ethSpent uint256.Int
var ethSpentTotal uint256.Int
var totalGas uint256.Int
count := 0
for i, tx := range body.Transactions {
ethSpent.SetUint64(tx.GetGas())
totalGas.Add(&totalGas, &ethSpent)
if senders[i] == header.Coinbase {
continue // Mining pool sending payout potentially with abnormally low fee, skip
}
ethSpent.Mul(&ethSpent, tx.GetPrice())
ethSpentTotal.Add(&ethSpentTotal, &ethSpent)
count++
}
if count > 0 {
ethSpentTotal.Div(&ethSpentTotal, &totalGas)
ethSpentTotal.Div(&ethSpentTotal, &gwei)
gasPrice := ethSpentTotal.Uint64()
burntGas += header.GasUsed
fmt.Fprintf(w, "%d, %d\n", burntGas, gasPrice)
}
if blockNumber%100_000 == 0 {
log.Info("Processed", "blocks", blockNumber)
}
return nil
}); err1 != nil {
return err1
}
return nil
return tx.Commit()
}

func extractHashes(chaindata string, blockStep uint64, blockTotal uint64, name string) error {
Expand Down Expand Up @@ -1626,9 +1621,9 @@ func extractHeaders(chaindata string, blockStep uint64, blockTotal uint64, name
}

func extractBodies(chaindata string, block uint64) error {
db := ethdb.MustOpen(chaindata)
db := ethdb.MustOpen(chaindata).RwKV()
defer db.Close()
tx, err := db.Begin(context.Background(), ethdb.RO)
tx, err := db.BeginRo(context.Background())
if err != nil {
return err
}
Expand All @@ -1645,13 +1640,13 @@ func extractBodies(chaindata string, block uint64) error {
}
blockNumber := binary.BigEndian.Uint64(k[:8])
blockHash := common.BytesToHash(k[8:])
body := rawdb.ReadBody(db, blockHash, blockNumber)
body := rawdb.ReadBody(tx, blockHash, blockNumber)
b, err := rlp.EncodeToBytes(body)
if err != nil {
return err
}
fmt.Printf("Body %d %x: %x\n", blockNumber, blockHash, b)
header := rawdb.ReadHeader(db, blockHash, blockNumber)
header := rawdb.ReadHeader(tx, blockHash, blockNumber)
b, err = rlp.EncodeToBytes(header)
if err != nil {
return err
Expand Down Expand Up @@ -1829,9 +1824,6 @@ func main() {
fmt.Printf("Error: %v\n", err)
}

case "fixAccount":
fixAccount(*chaindata, common.HexToHash(*account), common.HexToHash(*hash))

case "nextIncarnation":
nextIncarnation(*chaindata, common.HexToHash(*account))

Expand Down
2 changes: 1 addition & 1 deletion cmd/integration/commands/state_stages.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -290,7 +290,7 @@ func syncBySmallSteps(db ethdb.Database, miningConfig params.MiningConfig, ctx c
break
}

nextBlock, _, err := rawdb.ReadBlockByNumberWithSenders(tx, execAtBlock+1)
nextBlock, _, err := rawdb.ReadBlockByNumberWithSenders(tx.(ethdb.HasTx).Tx(), execAtBlock+1)
if err != nil {
panic(err)
}
Expand Down
2 changes: 1 addition & 1 deletion cmd/pics/state.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -293,7 +293,7 @@ func initialState1() error {
if err != nil {
return err
}
genesis := rawdb.ReadBlock(db, genesisHash, 0)
genesis := rawdb.ReadBlockDeprecated(db, genesisHash, 0)
if err != nil {
return err
}
Expand Down
Loading

0 comments on commit aacc457

Please sign in to comment.