temp

api/accounts/accounts.go

@@ -48,7 +48,7 @@ func New(
 
 func (a *Accounts) getCode(addr thor.Address, summary *chain.BlockSummary) ([]byte, error) {
 	code, err := a.stater.
-		NewState(summary.Header.StateRoot(), summary.Header.Number(), summary.Conflicts, summary.SteadyNum).
+		NewState(summary.Header.StateRoot(), summary.Version()).
 		GetCode(addr)
 	if err != nil {
 		return nil, err
@@ -74,7 +74,7 @@ func (a *Accounts) handleGetCode(w http.ResponseWriter, req *http.Request) error
 }
 
 func (a *Accounts) getAccount(addr thor.Address, summary *chain.BlockSummary) (*Account, error) {
-	state := a.stater.NewState(summary.Header.StateRoot(), summary.Header.Number(), summary.Conflicts, summary.SteadyNum)
+	state := a.stater.NewState(summary.Header.StateRoot(), summary.Version())
 	b, err := state.GetBalance(addr)
 	if err != nil {
 		return nil, err
@@ -97,7 +97,7 @@ func (a *Accounts) getAccount(addr thor.Address, summary *chain.BlockSummary) (*
 
 func (a *Accounts) getStorage(addr thor.Address, key thor.Bytes32, summary *chain.BlockSummary) (thor.Bytes32, error) {
 	storage, err := a.stater.
-		NewState(summary.Header.StateRoot(), summary.Header.Number(), summary.Conflicts, summary.SteadyNum).
+		NewState(summary.Header.StateRoot(), summary.Version()).
 		GetStorage(addr, key)
 
 	if err != nil {
@@ -200,7 +200,7 @@ func (a *Accounts) batchCall(ctx context.Context, batchCallData *BatchCallData,
 		return nil, err
 	}
 	header := summary.Header
-	state := a.stater.NewState(header.StateRoot(), header.Number(), summary.Conflicts, summary.SteadyNum)
+	state := a.stater.NewState(summary.Header.StateRoot(), summary.Version())
 
 	signer, _ := header.Signer()
 	rt := runtime.New(a.repo.NewChain(header.ParentID()), state,

api/debug/debug.go

@@ -217,7 +217,7 @@ func (d *Debug) handleTraceCall(w http.ResponseWriter, req *http.Request) error
 
 func (d *Debug) traceCall(ctx context.Context, tracer tracers.Tracer, summary *chain.BlockSummary, txCtx *xenv.TransactionContext, gas uint64, clause *tx.Clause) (interface{}, error) {
 	header := summary.Header
-	state := d.stater.NewState(header.StateRoot(), header.Number(), summary.Conflicts, summary.SteadyNum)
+	state := d.stater.NewState(summary.Header.StateRoot(), summary.Version())
 	signer, _ := header.Signer()
 	rt := runtime.New(
 		d.repo.NewChain(header.ID()),
@@ -272,7 +272,7 @@ func (d *Debug) debugStorage(ctx context.Context, contractAddress thor.Address,
 }
 
 func storageRangeAt(t *muxdb.Trie, start []byte, maxResult int) (*StorageRangeResult, error) {
-	it := trie.NewIterator(t.NodeIterator(start, 0))
+	it := trie.NewIterator(t.NodeIterator(start, trie.Version{}))
 	result := StorageRangeResult{Storage: StorageMap{}}
 	for i := 0; i < maxResult && it.Next(); i++ {
 		_, content, _, err := rlp.Split(it.Value)

bft/engine.go

@@ -322,7 +322,7 @@ func (engine *BFTEngine) findCheckpointByQuality(target uint32, finalized, paren
 }
 
 func (engine *BFTEngine) getMaxBlockProposers(sum *chain.BlockSummary) (uint64, error) {
-	state := engine.stater.NewState(sum.Header.StateRoot(), sum.Header.Number(), sum.Conflicts, sum.SteadyNum)
+	state := engine.stater.NewState(sum.Header.StateRoot(), sum.Version())
 	params, err := builtin.Params.Native(state).Get(thor.KeyMaxBlockProposers)
 	if err != nil {
 		return 0, err

builtin/authority/authority_test.go

@@ -21,7 +21,7 @@ func M(a ...interface{}) []interface{} {
 
 func TestAuthority(t *testing.T) {
 	db := muxdb.NewMem()
-	st := state.New(db, thor.Bytes32{}, 0, 0, 0)
+	st := state.New(db, thor.Bytes32{}, 0)
 
 	p1 := thor.BytesToAddress([]byte("p1"))
 	p2 := thor.BytesToAddress([]byte("p2"))

builtin/energy/energy_test.go

@@ -21,7 +21,7 @@ func M(a ...interface{}) []interface{} {
 
 func TestEnergy(t *testing.T) {
 	db := muxdb.NewMem()
-	st := state.New(db, thor.Bytes32{}, 0, 0, 0)
+	st := state.New(db, thor.Bytes32{}, 0)
 
 	acc := thor.BytesToAddress([]byte("a1"))
 
@@ -44,7 +44,7 @@ func TestEnergy(t *testing.T) {
 
 func TestEnergyGrowth(t *testing.T) {
 	db := muxdb.NewMem()
-	st := state.New(db, thor.Bytes32{}, 0, 0, 0)
+	st := state.New(db, thor.Bytes32{}, 0)
 
 	acc := thor.BytesToAddress([]byte("a1"))
 

builtin/executor_test.go

@@ -73,7 +73,7 @@ func initExectorTest() *ctest {
 	})
 
 	repo, _ := chain.NewRepository(db, b0)
-	st := state.New(db, b0.Header().StateRoot(), 0, 0, 0)
+	st := state.New(db, b0.Header().StateRoot(), 0)
 	chain := repo.NewChain(b0.Header().ID())
 
 	rt := runtime.New(chain, st, &xenv.BlockContext{Time: uint64(time.Now().Unix())}, thor.NoFork)

builtin/params/params_test.go

@@ -17,7 +17,7 @@ import (
 
 func TestParamsGetSet(t *testing.T) {
 	db := muxdb.NewMem()
-	st := state.New(db, thor.Bytes32{}, 0, 0, 0)
+	st := state.New(db, thor.Bytes32{}, 0)
 	setv := big.NewInt(10)
 	key := thor.BytesToBytes32([]byte("key"))
 	p := New(thor.BytesToAddress([]byte("par")), st)

builtin/prototype/prototype_test.go

@@ -22,7 +22,7 @@ func M(a ...interface{}) []interface{} {
 
 func TestPrototype(t *testing.T) {
 	db := muxdb.NewMem()
-	st := state.New(db, thor.Bytes32{}, 0, 0, 0)
+	st := state.New(db, thor.Bytes32{}, 0)
 
 	proto := prototype.New(thor.BytesToAddress([]byte("proto")), st)
 	binding := proto.Bind(thor.BytesToAddress([]byte("binding")))

builtin/prototype_native.go

@@ -94,7 +94,7 @@ func init() {
 			}
 
 			env.UseGas(thor.SloadGas)
-			state := env.State().Checkout(summary.Header.StateRoot(), summary.Header.Number(), summary.Conflicts, summary.SteadyNum)
+			state := env.State().Checkout(summary.Header.StateRoot(), summary.Version())
 
 			env.UseGas(thor.GetBalanceGas)
 			val, err := state.GetBalance(thor.Address(args.Self))
@@ -136,7 +136,7 @@ func init() {
 			}
 
 			env.UseGas(thor.SloadGas)
-			state := env.State().Checkout(summary.Header.StateRoot(), summary.Header.Number(), summary.Conflicts, summary.SteadyNum)
+			state := env.State().Checkout(summary.Header.StateRoot(), summary.Version())
 
 			env.UseGas(thor.GetBalanceGas)
 			val, err := state.GetEnergy(thor.Address(args.Self), summary.Header.Timestamp())

chain/chain.go

@@ -7,6 +7,7 @@ package chain
 
 import (
 	"encoding/binary"
+	"fmt"
 	"math"
 	"sort"
 
@@ -64,9 +65,9 @@ func newChain(repo *Repository, headID thor.Bytes32) *Chain {
 		func() (*muxdb.Trie, error) {
 			if indexTrie == nil && initErr == nil {
 				if summary, err := repo.GetBlockSummary(headID); err == nil {
-					indexTrie = repo.db.NewNonCryptoTrie(IndexTrieName, trie.NonCryptoNodeHash, summary.Header.Number(), summary.Conflicts)
+					indexTrie = repo.db.NewTrie(IndexTrieName, thor.BytesToBytes32([]byte{1}), summary.Version())
 				} else {
-					initErr = errors.Wrap(err, "lazy init chain")
+					initErr = errors.Wrap(err, fmt.Sprintf("lazy init chain, head=%v", headID))
 				}
 			}
 			return indexTrie, initErr
@@ -116,23 +117,27 @@ func (c *Chain) GetTransactionMeta(id thor.Bytes32) (*TxMeta, error) {
 	iter := c.repo.txIndexer.Iterate(kv.Range(*util.BytesPrefix(id[:])))
 	defer iter.Release()
 	for iter.Next() {
-		if len(iter.Key()) != 64 { // skip the pure txid key
+		if len(iter.Key()) != 32+8 { // skip the pure txid key
 			continue
 		}
 
-		blockID := thor.BytesToBytes32(iter.Key()[32:])
+		major := binary.BigEndian.Uint32(iter.Key()[32:])
+		minor := binary.BigEndian.Uint32(iter.Key()[32+4:])
 
-		has, err := c.HasBlock(blockID)
+		bs, err := c.GetBlockSummary(major)
 		if err != nil {
-			return nil, err
+			if !c.IsNotFound(err) {
+				return nil, err
+			}
+			continue
 		}
-		if has {
+		if bs.Conflicts == minor {
 			var sMeta storageTxMeta
 			if err := rlp.DecodeBytes(iter.Value(), &sMeta); err != nil {
 				return nil, err
 			}
 			return &TxMeta{
-				BlockID:  blockID,
+				BlockID:  bs.Header.ID(),
 				Index:    sMeta.Index,
 				Reverted: sMeta.Reverted,
 			}, nil
@@ -154,13 +159,7 @@ func (c *Chain) HasTransaction(txid thor.Bytes32, txBlockRef uint32) (bool, erro
 	}
 	// tx block ref too old, fallback to retrieve tx meta.
 	if headNum-txBlockRef > 100 {
-		if _, err := c.GetTransactionMeta(txid); err != nil {
-			if c.IsNotFound(err) {
-				return false, nil
-			}
-			return false, err
-		}
-		return true, nil
+		return c.repo.txIndexer.Has(txid[:])
 	}
 
 	// iterate block summaries from head block to ref block,
@@ -357,17 +356,16 @@ func (r *Repository) indexBlock(parentConflicts uint32, newBlockID thor.Bytes32,
 		newNum = block.Number(newBlockID)
 		root   thor.Bytes32
 	)
-
 	if newNum != 0 { // not a genesis block
-		root = trie.NonCryptoNodeHash
+		root = thor.BytesToBytes32([]byte{1})
 	}
 
-	trie := r.db.NewNonCryptoTrie(IndexTrieName, root, newNum-1, parentConflicts)
+	rev := trie.Version{Major: newNum - 1, Minor: parentConflicts}
+
+	t := r.db.NewTrie(IndexTrieName, root, rev)
 	// map block number to block ID
-	if err := trie.Update(newBlockID[:4], newBlockID[:], nil); err != nil {
+	if err := t.Update(newBlockID[:4], newBlockID[:], nil); err != nil {
 		return err
 	}
-
-	_, commit := trie.Stage(newNum, newConflicts)
-	return commit()
+	return t.Commit(trie.Version{Major: newNum, Minor: newConflicts}, true)
 }

chain/persist.go

@@ -12,6 +12,7 @@ import (
 	"github.com/vechain/thor/v2/block"
 	"github.com/vechain/thor/v2/kv"
 	"github.com/vechain/thor/v2/thor"
+	"github.com/vechain/thor/v2/trie"
 	"github.com/vechain/thor/v2/tx"
 )
 
@@ -26,7 +27,10 @@ type BlockSummary struct {
 	Txs       []thor.Bytes32
 	Size      uint64
 	Conflicts uint32
-	SteadyNum uint32
+}
+
+func (s *BlockSummary) Version() trie.Version {
+	return trie.Version{Major: s.Header.Number(), Minor: s.Conflicts}
 }
 
 // the key for tx/receipt.
@@ -43,12 +47,12 @@ func (k *txKey) SetIndex(i uint64) {
 	binary.BigEndian.PutUint64(k[33:], i)
 }
 
-func saveRLP(w kv.Putter, key []byte, val interface{}) error {
-	data, err := rlp.EncodeToBytes(val)
-	if err != nil {
+func saveRLP(w kv.Putter, key []byte, val interface{}, sw *sliceWriter) error {
+	*sw = (*sw)[:0]
+	if err := rlp.Encode(sw, val); err != nil {
 		return err
 	}
-	return w.Put(key, data)
+	return w.Put(key, *sw)
 }
 
 func loadRLP(r kv.Getter, key []byte, val interface{}) error {
@@ -59,10 +63,6 @@ func loadRLP(r kv.Getter, key []byte, val interface{}) error {
 	return rlp.DecodeBytes(data, val)
 }
 
-func saveBlockSummary(w kv.Putter, summary *BlockSummary) error {
-	return saveRLP(w, summary.Header.ID().Bytes(), summary)
-}
-
 func indexChainHead(w kv.Putter, header *block.Header) error {
 	if err := w.Delete(header.ParentID().Bytes()); err != nil {
 		return err
@@ -79,10 +79,6 @@ func loadBlockSummary(r kv.Getter, id thor.Bytes32) (*BlockSummary, error) {
 	return &summary, nil
 }
 
-func saveTransaction(w kv.Putter, key txKey, tx *tx.Transaction) error {
-	return saveRLP(w, key[:], tx)
-}
-
 func loadTransaction(r kv.Getter, key txKey) (*tx.Transaction, error) {
 	var tx tx.Transaction
 	if err := loadRLP(r, key[:], &tx); err != nil {
@@ -91,14 +87,17 @@ func loadTransaction(r kv.Getter, key txKey) (*tx.Transaction, error) {
 	return &tx, nil
 }
 
-func saveReceipt(w kv.Putter, key txKey, receipt *tx.Receipt) error {
-	return saveRLP(w, key[:], receipt)
-}
-
 func loadReceipt(r kv.Getter, key txKey) (*tx.Receipt, error) {
 	var receipt tx.Receipt
 	if err := loadRLP(r, key[:], &receipt); err != nil {
 		return nil, err
 	}
 	return &receipt, nil
 }
+
+type sliceWriter []byte
+
+func (s *sliceWriter) Write(data []byte) (n int, err error) {
+	*s = append(*s, data...)
+	return len(data), nil
+}