diff --git a/backend/internal/e2e/data_test.go b/backend/internal/e2e/data_test.go
new file mode 100644
index 000000000..c75f039e1
--- /dev/null
+++ b/backend/internal/e2e/data_test.go
@@ -0,0 +1,94 @@
+package e2e
+
+import (
+	"context"
+	"encoding/hex"
+	"fmt"
+	"math/big"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common"
+
+	"github.com/gobitfly/beaconchain/internal/th"
+	"github.com/gobitfly/beaconchain/pkg/commons/db2/data"
+	"github.com/gobitfly/beaconchain/pkg/commons/db2/database"
+	"github.com/gobitfly/beaconchain/pkg/commons/db2/databasetest"
+	"github.com/gobitfly/beaconchain/pkg/commons/indexer"
+	"github.com/gobitfly/beaconchain/pkg/commons/rpc"
+	"github.com/gobitfly/beaconchain/pkg/commons/types"
+)
+
+func TestStoreWithBackend(t *testing.T) {
+	clientBT, adminBT := databasetest.NewBigTable(t)
+	bigtable, err := database.NewBigTableWithClient(context.Background(), clientBT, adminBT, data.Schema)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	store := data.NewStore(database.Wrap(bigtable, data.Table))
+	backend := th.NewBackend(t)
+	_, usdt := backend.DeployToken(t, "usdt", "usdt", backend.BankAccount.From)
+
+	transform := indexer.NewTransformer(indexer.NoopCache{})
+	indexer := indexer.New(store, transform.Tx, transform.ERC20)
+
+	client, err := rpc.NewErigonClient(backend.Endpoint)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	var addresses []common.Address
+	for i := 0; i < 10; i++ {
+		temp := th.CreateEOA(t)
+		addresses = append(addresses, temp.From)
+		for j := 0; j < 25; j++ {
+			if err := backend.Client().SendTransaction(context.Background(), backend.MakeTx(t, backend.BankAccount, &temp.From, big.NewInt(1), nil)); err != nil {
+				t.Fatal(err)
+			}
+			if _, err := usdt.Mint(backend.BankAccount.TransactOpts, temp.From, big.NewInt(1)); err != nil {
+				t.Fatal(i, j, err)
+			}
+			backend.Commit()
+			lastBlock, err := backend.Client().BlockNumber(context.Background())
+			if err != nil {
+				t.Fatal(err)
+			}
+			block, _, err := client.GetBlock(int64(lastBlock), "geth")
+			if err != nil {
+				t.Fatal(err)
+			}
+			if err := indexer.IndexBlocksWithTransformers(fmt.Sprintf("%d", backend.ChainID), []*types.Eth1Block{block}); err != nil {
+				t.Fatal(err)
+			}
+		}
+	}
+
+	efficiencies := make(map[string]int64)
+	interactions, _, err := store.Get(addresses, nil, 25, data.WithDatabaseStats(func(msg string, args ...any) {
+		var efficiency int64
+		var rowRange string
+		for i := 0; i < len(args); i = i + 2 {
+			if args[i].(string) == database.KeyStatEfficiency {
+				efficiency = args[i+1].(int64)
+			}
+			if args[i].(string) == database.KeyStatRange {
+				rowRange = args[i+1].(string)
+			}
+		}
+		efficiencies[rowRange] = efficiency
+	}))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, interaction := range interactions {
+		t.Log(interaction.Type, interaction.ChainID, "0x"+interaction.From, "0x"+interaction.To, "0x"+hex.EncodeToString(interaction.Hash), interaction.Time)
+	}
+	if got, want := len(efficiencies), len(addresses); got != want {
+		t.Errorf("got %d want %d", got, want)
+	}
+	for rowRange, efficiency := range efficiencies {
+		if got, want := efficiency, int64(1); got != want {
+			t.Errorf("efficiency for %s: got %d, want %d", rowRange, got, want)
+		}
+	}
+}
diff --git a/backend/pkg/commons/db2/data/data.go b/backend/pkg/commons/db2/data/data.go
index 24879dc01..82690245e 100644
--- a/backend/pkg/commons/db2/data/data.go
+++ b/backend/pkg/commons/db2/data/data.go
@@ -26,112 +26,45 @@ func NewStore(store database.Database) Store {
 	}
 }
 
-type TransferWithIndexes struct {
-	Indexed  *types.Eth1ERC20Indexed
-	TxIndex  int
-	LogIndex int
-}
-
-func (store Store) BlockERC20TransfersToItems(chainID string, transfers []TransferWithIndexes) (map[string][]database.Item, error) {
-	items := make(map[string][]database.Item)
-	for _, transfer := range transfers {
-		b, err := proto.Marshal(transfer.Indexed)
-		if err != nil {
-			return nil, err
-		}
-		key := keyERC20(chainID, transfer.Indexed.ParentHash, transfer.LogIndex)
-		item := []database.Item{{Family: defaultFamily, Column: key}}
-		items[key] = []database.Item{{Family: defaultFamily, Column: dataColumn, Data: b}}
-
-		items[keyERC20Time(chainID, transfer.Indexed, transfer.Indexed.From, transfer.TxIndex, transfer.LogIndex)] = item
-		items[keyERC20Time(chainID, transfer.Indexed, transfer.Indexed.To, transfer.TxIndex, transfer.LogIndex)] = item
-
-		items[keyERC20ContractAllTime(chainID, transfer.Indexed, transfer.TxIndex, transfer.LogIndex)] = item
-		items[keyERC20ContractTime(chainID, transfer.Indexed, transfer.Indexed.From, transfer.TxIndex, transfer.LogIndex)] = item
-		items[keyERC20ContractTime(chainID, transfer.Indexed, transfer.Indexed.To, transfer.TxIndex, transfer.LogIndex)] = item
-
-		items[keyERC20To(chainID, transfer.Indexed, transfer.TxIndex, transfer.LogIndex)] = item
-		items[keyERC20From(chainID, transfer.Indexed, transfer.TxIndex, transfer.LogIndex)] = item
-		items[keyERC20Sent(chainID, transfer.Indexed, transfer.TxIndex, transfer.LogIndex)] = item
-		items[keyERC20Received(chainID, transfer.Indexed, transfer.TxIndex, transfer.LogIndex)] = item
-	}
-	return items, nil
+func (store Store) AddItems(items map[string][]database.Item) error {
+	return store.db.BulkAdd(items)
 }
 
 func (store Store) AddBlockERC20Transfers(chainID string, transactions []TransferWithIndexes) error {
-	items, err := store.BlockERC20TransfersToItems(chainID, transactions)
+	items, err := BlockERC20TransfersToItemsV2(chainID, transactions)
 	if err != nil {
 		return err
 	}
 	return store.db.BulkAdd(items)
 }
 
-func (store Store) BlockTransactionsToItems(chainID string, transactions []*types.Eth1TransactionIndexed) (map[string][]database.Item, error) {
-	items := make(map[string][]database.Item)
-	for i, transaction := range transactions {
-		b, err := proto.Marshal(transaction)
-		if err != nil {
-			return nil, err
-		}
-		key := keyTx(chainID, transaction.GetHash())
-		item := []database.Item{{Family: defaultFamily, Column: key}}
-		items[key] = []database.Item{{Family: defaultFamily, Column: dataColumn, Data: b}}
-		items[keyTxSent(chainID, transaction, i)] = item
-		items[keyTxReceived(chainID, transaction, i)] = item
-
-		items[keyTxTime(chainID, transaction, transaction.To, i)] = item
-		items[keyTxBlock(chainID, transaction, transaction.To, i)] = item
-		items[keyTxMethod(chainID, transaction, transaction.To, i)] = item
-
-		items[keyTxTime(chainID, transaction, transaction.From, i)] = item
-		items[keyTxBlock(chainID, transaction, transaction.From, i)] = item
-		items[keyTxMethod(chainID, transaction, transaction.From, i)] = item
-
-		if transaction.ErrorMsg != "" {
-			items[keyTxError(chainID, transaction, transaction.To, i)] = item
-			items[keyTxError(chainID, transaction, transaction.From, i)] = item
-		}
-
-		if transaction.IsContractCreation {
-			items[keyTxContractCreation(chainID, transaction, transaction.To, i)] = item
-			items[keyTxContractCreation(chainID, transaction, transaction.From, i)] = item
-		}
-	}
-	return items, nil
-}
-
 func (store Store) AddBlockTransactions(chainID string, transactions []*types.Eth1TransactionIndexed) error {
-	items, err := store.BlockTransactionsToItems(chainID, transactions)
+	items, err := BlockTransactionsToItemsV2(chainID, transactions)
 	if err != nil {
 		return err
 	}
 	return store.db.BulkAdd(items)
 }
 
-func (store Store) Get(chainIDs []string, addresses []common.Address, prefixes map[string]map[string]string, limit int64, opts ...Option) ([]*Interaction, map[string]map[string]string, error) {
-	sources := map[formatType]unMarshalInteraction{
-		typeTx:       unMarshalTx,
-		typeTransfer: unMarshalTransfer,
-	}
+func (store Store) Get(addresses []common.Address, prefixes map[string]string, limit int64, opts ...Option) ([]*Interaction, map[string]string, error) {
 	options := apply(opts)
-	if options.ignoreTxs {
-		delete(sources, typeTx)
+
+	filter, err := newQueryFilter(options)
+	if err != nil {
+		return nil, nil, err
 	}
-	if options.ignoreTransfers {
-		delete(sources, typeTransfer)
+	databaseOptions := []database.Option{
+		database.WithLimit(limit),
+		database.WithOpenRange(true),
 	}
-	var interactions []*interactionWithInfo
-	for interactionType, unMarshalFunc := range sources {
-		filter, err := makeFilters(options, interactionType)
-		if err != nil {
-			return nil, nil, err
-		}
-		temp, err := store.getBy(unMarshalFunc, chainIDs, addresses, prefixes, limit, filter)
-		if err != nil {
-			return nil, nil, err
-		}
-		interactions = append(interactions, temp...)
+	if options.statsReporter != nil {
+		databaseOptions = append(databaseOptions, database.WithStats(options.statsReporter))
+	}
+	interactions, err := store.getBy(addresses, prefixes, filter, databaseOptions)
+	if err != nil {
+		return nil, nil, err
 	}
+
 	sort.Sort(byTimeDesc(interactions))
 	if int64(len(interactions)) > limit {
 		interactions = interactions[:limit]
@@ -139,59 +72,59 @@ func (store Store) Get(chainIDs []string, addresses []common.Address, prefixes m
 
 	var res []*Interaction
 	if prefixes == nil {
-		prefixes = make(map[string]map[string]string)
+		prefixes = make(map[string]string)
 	}
 	for i := 0; i < len(interactions); i++ {
-		if prefixes[interactions[i].chainID] == nil {
-			prefixes[interactions[i].chainID] = make(map[string]string)
-		}
-		prefixes[interactions[i].chainID][interactions[i].root] = interactions[i].key
+		prefixes[interactions[i].root] = interactions[i].key
 		res = append(res, interactions[i].Interaction)
 	}
 	return res, prefixes, nil
 }
 
-func (store Store) getBy(unMarshal unMarshalInteraction, chainIDs []string, addresses []common.Address, prefixes map[string]map[string]string, limit int64, condition filter) ([]*interactionWithInfo, error) {
+func (store Store) getBy(addresses []common.Address, prefixes map[string]string, condition filter, databaseOptions []database.Option) ([]*interactionWithInfo, error) {
 	var interactions []*interactionWithInfo
-	for _, chainID := range chainIDs {
-		for _, address := range addresses {
-			root := condition.get(chainID, address)
-			prefix := root
-			if prefixes != nil && prefixes[chainID] != nil && prefixes[chainID][root] != "" {
-				prefix = prefixes[chainID][root]
+	for _, address := range addresses {
+		root := condition.get(address)
+		prefix := root
+		if prefixes != nil && prefixes[root] != "" {
+			prefix = prefixes[root]
+		}
+		upper := condition.limit(root)
+		indexRows, err := store.db.GetRowsRange(upper, prefix, databaseOptions...)
+		if err != nil {
+			if errors.Is(err, database.ErrNotFound) {
+				continue
 			}
-			upper := condition.limit(root)
-			indexRows, err := store.db.GetRowsRange(upper, prefix, database.WithLimit(limit), database.WithOpenRange(true))
-			if err != nil {
-				if errors.Is(err, database.ErrNotFound) {
-					continue
-				}
-				return nil, err
+			return nil, err
+		}
+		txKeys := make(map[string]string)
+		for _, row := range indexRows {
+			for key := range row.Values {
+				txKey := strings.TrimPrefix(key, fmt.Sprintf("%s:", defaultFamily))
+				txKeys[txKey] = row.Key
 			}
-			txKeys := make(map[string]string)
-			for _, row := range indexRows {
-				for key := range row.Values {
-					txKey := strings.TrimPrefix(key, fmt.Sprintf("%s:", defaultFamily))
-					txKeys[txKey] = row.Key
-				}
+		}
+		txRows, err := store.db.GetRowsWithKeys(maps.Keys(txKeys))
+		if err != nil {
+			return nil, err
+		}
+		for _, row := range txRows {
+			parts := strings.Split(row.Key, ":")
+			unMarshal := unMarshalTx
+			if parts[0] == "ERC20" {
+				unMarshal = unMarshalTransfer
 			}
-			txRows, err := store.db.GetRowsWithKeys(maps.Keys(txKeys))
+			interaction, err := unMarshal(row.Values[fmt.Sprintf("%s:%s", defaultFamily, dataColumn)])
 			if err != nil {
 				return nil, err
 			}
-			for _, row := range txRows {
-				interaction, err := unMarshal(row.Values[fmt.Sprintf("%s:%s", defaultFamily, dataColumn)])
-				if err != nil {
-					return nil, err
-				}
-				interaction.ChainID = chainID
-				interactions = append(interactions, &interactionWithInfo{
-					Interaction: interaction,
-					chainID:     chainID,
-					root:        root,
-					key:         txKeys[row.Key],
-				})
-			}
+			interaction.ChainID = parts[1]
+			interactions = append(interactions, &interactionWithInfo{
+				Interaction: interaction,
+				chainID:     parts[1],
+				root:        root,
+				key:         txKeys[row.Key],
+			})
 		}
 	}
 	return interactions, nil
@@ -231,8 +164,6 @@ type Interaction struct {
 
 var erc20Transfer, _ = hex.DecodeString("a9059cbb")
 
-type unMarshalInteraction func(b []byte) (*Interaction, error)
-
 func unMarshalTx(b []byte) (*Interaction, error) {
 	tx := &types.Eth1TransactionIndexed{}
 	if err := proto.Unmarshal(b, tx); err != nil {
diff --git a/backend/pkg/commons/db2/data/data_external_test.go b/backend/pkg/commons/db2/data/data_external_test.go
index 04afd2bd3..efdaa9907 100644
--- a/backend/pkg/commons/db2/data/data_external_test.go
+++ b/backend/pkg/commons/db2/data/data_external_test.go
@@ -77,7 +77,7 @@ func TestStoreExternal(t *testing.T) {
 			chainIDs:  chainIDs,
 			addresses: addresses,
 			opts: []data.Option{
-				data.IgnoreTransfers(),
+				data.OnlyTransactions(),
 				data.ByMethod("a9059cbb"),
 			},
 		},
@@ -87,15 +87,15 @@ func TestStoreExternal(t *testing.T) {
 			chainIDs:  chainIDs,
 			addresses: addresses,
 			opts: []data.Option{
-				data.IgnoreTransactions(),
+				data.OnlyTransactions(),
 			},
 		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			var lastPrefixes map[string]map[string]string
+			var lastPrefixes map[string]string
 			for i := 0; i < tt.scroll+1; i++ {
-				interactions, prefixes, err := store.Get(chainIDs, addresses, lastPrefixes, tt.limit, tt.opts...)
+				interactions, prefixes, err := store.Get(addresses, lastPrefixes, tt.limit, tt.opts...)
 				if err != nil {
 					t.Fatal(err)
 				}
diff --git a/backend/pkg/commons/db2/data/data_test.go b/backend/pkg/commons/db2/data/data_test.go
index 0942331a6..18f477f9f 100644
--- a/backend/pkg/commons/db2/data/data_test.go
+++ b/backend/pkg/commons/db2/data/data_test.go
@@ -3,13 +3,10 @@ package data
 import (
 	"context"
 	"encoding/hex"
-	"slices"
-	"sort"
 	"testing"
 	"time"
 
 	"github.com/ethereum/go-ethereum/common"
-	"golang.org/x/exp/maps"
 	"google.golang.org/protobuf/types/known/timestamppb"
 
 	"github.com/gobitfly/beaconchain/pkg/commons/db2/database"
@@ -125,7 +122,7 @@ func TestStore(t *testing.T) {
 				},
 			},
 			limit:          1,
-			opts:           []Option{IgnoreTransfers(), ByMethod(hex.EncodeToString([]byte("foo")))},
+			opts:           []Option{OnlyTransactions(), ByMethod(hex.EncodeToString([]byte("foo")))},
 			addresses:      []common.Address{alice},
 			expectedHashes: []string{"hash1"},
 		},
@@ -139,7 +136,7 @@ func TestStore(t *testing.T) {
 				},
 			},
 			limit:          1,
-			opts:           []Option{WithTimeRange(timestamppb.New(t0), timestamppb.New(t0.Add(1*time.Second)))},
+			opts:           []Option{WithTimeRange(timestamppb.New(t0), timestamppb.New(t1))},
 			addresses:      []common.Address{alice},
 			expectedHashes: []string{"hash2", "hash1"},
 		},
@@ -170,7 +167,8 @@ func TestStore(t *testing.T) {
 			opts:           []Option{OnlyReceived()},
 			addresses:      []common.Address{bob},
 			expectedHashes: []string{"hash3", "hash1"},
-		}, {
+		},
+		{
 			name: "only transfers",
 			txs: map[string][][]*types.Eth1TransactionIndexed{
 				"1": {
@@ -184,7 +182,7 @@ func TestStore(t *testing.T) {
 				},
 			},
 			limit:          1,
-			opts:           []Option{IgnoreTransactions()},
+			opts:           []Option{OnlyTransfers()},
 			addresses:      []common.Address{alice},
 			expectedHashes: []string{"hash3", "hash1"},
 		},
@@ -202,7 +200,7 @@ func TestStore(t *testing.T) {
 				},
 			},
 			limit:          1,
-			opts:           []Option{IgnoreTransfers()},
+			opts:           []Option{OnlyTransactions()},
 			addresses:      []common.Address{alice},
 			expectedHashes: []string{"hash3", "hash1"},
 		},
@@ -242,7 +240,7 @@ func TestStore(t *testing.T) {
 				},
 			},
 			limit:          2,
-			opts:           []Option{IgnoreTransactions(), ByAsset(usdc), WithTimeRange(timestamppb.New(t0.Add(1*time.Second)), timestamppb.New(t0.Add(3*time.Second)))},
+			opts:           []Option{OnlyTransfers(), ByAsset(usdc), WithTimeRange(timestamppb.New(t1), timestamppb.New(t0.Add(3*time.Second)))},
 			addresses:      []common.Address{alice},
 			expectedHashes: []string{"hash4", "hash3", "hash2"},
 		},
@@ -258,7 +256,7 @@ func TestStore(t *testing.T) {
 				},
 			},
 			limit:          2,
-			opts:           []Option{IgnoreTransactions(), OnlySent(), ByAsset(usdc), WithTimeRange(timestamppb.New(t0.Add(1*time.Second)), timestamppb.New(t0.Add(3*time.Second)))},
+			opts:           []Option{OnlyTransfers(), OnlySent(), ByAsset(usdc), WithTimeRange(timestamppb.New(t1), timestamppb.New(t0.Add(3*time.Second)))},
 			addresses:      []common.Address{alice},
 			expectedHashes: []string{"hash3"},
 		},
@@ -274,7 +272,7 @@ func TestStore(t *testing.T) {
 				},
 			},
 			limit:          2,
-			opts:           []Option{IgnoreTransactions(), OnlyReceived(), ByAsset(usdc), WithTimeRange(timestamppb.New(t0.Add(1*time.Second)), timestamppb.New(t0.Add(3*time.Second)))},
+			opts:           []Option{OnlyTransfers(), OnlyReceived(), ByAsset(usdc), WithTimeRange(timestamppb.New(t1), timestamppb.New(t0.Add(3*time.Second)))},
 			addresses:      []common.Address{alice},
 			expectedHashes: []string{"hash3"},
 		},
@@ -296,12 +294,9 @@ func TestStore(t *testing.T) {
 					}
 				}
 			}
-			chainIDs := append(maps.Keys(tt.txs), maps.Keys(tt.transfers)...)
-			sort.Strings(chainIDs)
-			chainIDs = slices.Compact(chainIDs)
-			var suffix map[string]map[string]string
+			var suffix map[string]string
 			for i := int64(0); i < int64(len(tt.expectedHashes))/tt.limit; i++ {
-				txs, newSuffix, err := store.Get(chainIDs, tt.addresses, suffix, tt.limit, tt.opts...)
+				txs, newSuffix, err := store.Get(tt.addresses, suffix, tt.limit, tt.opts...)
 				if err != nil {
 					t.Fatalf("tx %d: %v", i, err)
 				}
@@ -322,7 +317,10 @@ func TestStore(t *testing.T) {
 	}
 }
 
-var t0 = time.Date(1970, 1, 1, 0, 0, 0, 0, time.UTC)
+var (
+	t0 = time.Date(1970, 1, 1, 0, 0, 0, 0, time.UTC)
+	t1 = time.Date(1970, 1, 1, 0, 0, 0, 0, time.UTC).Add(1 * time.Second)
+)
 
 func newTx(hash string, from, to common.Address, method string, delta int64) *types.Eth1TransactionIndexed {
 	return &types.Eth1TransactionIndexed{
diff --git a/backend/pkg/commons/db2/data/filter.go b/backend/pkg/commons/db2/data/filter.go
index aea5b19f6..ce3ba9f55 100644
--- a/backend/pkg/commons/db2/data/filter.go
+++ b/backend/pkg/commons/db2/data/filter.go
@@ -8,236 +8,87 @@ import (
 	"github.com/golang/protobuf/ptypes/timestamp"
 )
 
-type formatType string
-
-const (
-	typeTx       = formatType("tx")
-	typeTransfer = formatType("transfer")
-)
-
-type filterType string
-
-const (
-	byMethod        = filterType("byMethod")
-	bySent          = filterType("bySent")
-	byReceived      = filterType("byReceived")
-	byAsset         = filterType("byAsset")
-	byAssetSent     = filterType("byAssetSent")
-	byAssetReceived = filterType("byAssetReceived")
-)
-
 type filter interface {
-	get(chainID string, address common.Address) string
+	get(address common.Address) string
 	limit(prefix string) string
 }
 
-type chainFilter interface {
-	addByMethod(method string) error
-	addBySent() error
-	addByReceived() error
-	addByAsset(asset common.Address) error
-	addTimeRange(from *timestamp.Timestamp, to *timestamp.Timestamp) error
-	valid() error
-	filterType() filterType
-	filter
-}
-
-type chainFilterTx struct {
-	base     string
-	filtered filterType
-
-	method *string
-	from   *timestamp.Timestamp
-	to     *timestamp.Timestamp
-}
-
-func newChainFilterTx() *chainFilterTx {
-	return &chainFilterTx{
-		base: "<chainID>:I:TX:<address>:TIME",
-	}
-}
-
-func (c *chainFilterTx) addByMethod(method string) error {
-	if c.filtered != "" {
-		return fmt.Errorf("filter tx already filtered by %s", c.filtered)
-	}
-	c.base = "<chainID>:I:TX:<address>:METHOD:<method>"
-	c.method = &method
-	c.filtered = byMethod
-	return nil
-}
-
-func (c *chainFilterTx) addBySent() error {
-	if c.filtered != "" {
-		return fmt.Errorf("filter tx already filtered by %s", c.filtered)
-	}
-	c.base = "<chainID>:I:TX:<address>:TO"
-	c.filtered = bySent
-	return nil
-}
-
-func (c *chainFilterTx) addByReceived() error {
-	if c.filtered != "" {
-		return fmt.Errorf("filter tx already filtered by %s", c.filtered)
-	}
-	c.base = "<chainID>:I:TX:<address>:FROM"
-	c.filtered = byReceived
-	return nil
+func toHex(b []byte) string {
+	return fmt.Sprintf("%x", b)
 }
 
-func (c *chainFilterTx) addByAsset(common.Address) error {
-	return fmt.Errorf("cannot filter tx by asset")
+type queryFilter struct {
+	query    string
+	timeFrom *timestamp.Timestamp
+	timeTo   *timestamp.Timestamp
 }
 
-func (c *chainFilterTx) addTimeRange(from *timestamp.Timestamp, to *timestamp.Timestamp) error {
-	if from == nil || to == nil {
-		return fmt.Errorf("invalid time range: empty border")
+func newQueryFilter(options options) (*queryFilter, error) {
+	query := []string{"all"}
+	params := []string{"<address>"}
+	if options.onlySent && options.onlyReceived {
+		options.onlySent = false
+		options.onlyReceived = false
 	}
-	c.from = from
-	c.to = to
-	return nil
-}
-
-func (c *chainFilterTx) filterType() filterType {
-	return c.filtered
-}
-
-func (c *chainFilterTx) valid() error {
-	return nil
-}
-
-func (c *chainFilterTx) get(chainID string, address common.Address) string {
-	query := strings.Replace(c.base, "<chainID>", chainID, 1)
-	query = strings.Replace(query, "<address>", fmt.Sprintf("%x", address.Bytes()), 1)
-	if c.method != nil {
-		query = strings.Replace(query, "<method>", *c.method, 1)
+	if options.asset != nil && options.method != nil {
+		return nil, fmt.Errorf("cannot filter by method and by asset together")
 	}
-	if c.to != nil {
-		query = fmt.Sprintf("%s:%s", query, reversePaddedTimestamp(c.to))
+	if options.method != nil {
+		options.onlyTxs = true
 	}
-	return query
-}
-
-func (c *chainFilterTx) limit(prefix string) string {
-	if c.from != nil {
-		index := strings.LastIndex(prefix, ":")
-		return toSuccessor(fmt.Sprintf("%s:%s", prefix[:index], reversePaddedTimestamp(c.from)))
+	if options.asset != nil {
+		options.onlyTransfers = true
 	}
-	return toSuccessor(prefix)
-}
-
-type chainFilterTransfer struct {
-	base     string
-	filtered filterType
-
-	asset *common.Address
-	from  *timestamp.Timestamp
-	to    *timestamp.Timestamp
-}
-
-func newChainFilterTransfer() *chainFilterTransfer {
-	return &chainFilterTransfer{
-		base: "<chainID>:I:ERC20:<address>:TIME",
+	if options.onlyTxs && options.onlyTransfers {
+		options.onlyTxs = false
+		options.onlyTransfers = false
 	}
-}
-
-func (c *chainFilterTransfer) addByMethod(string) error {
-	return fmt.Errorf("cannot filter transfer by method")
-}
-
-func (c *chainFilterTransfer) addBySent() error {
-	if c.filtered != "" {
-		if c.filtered != byAsset {
-			return fmt.Errorf("filter transfer already filtered by %s", c.filtered)
-		}
-		return c.addByAssetSent()
+	if options.onlyReceived {
+		query[0] = "in"
+		params[0] = "<address>"
 	}
-	c.base = "<chainID>:I:ERC20:<address>:TOKEN_SENT"
-	c.filtered = bySent
-	return nil
-}
-
-func (c *chainFilterTransfer) addByReceived() error {
-	if c.filtered != "" {
-		if c.filtered != byAsset {
-			return fmt.Errorf("filter transfer already filtered by %s", c.filtered)
-		}
-		return c.addByAssetReceived()
+	if options.onlySent {
+		query[0] = "out"
+		params[0] = "<address>"
 	}
-	c.base = "<chainID>:I:ERC20:<address>:TOKEN_RECEIVED"
-	c.filtered = byReceived
-	return nil
-}
-
-func (c *chainFilterTransfer) addByAssetReceived() error {
-	c.base = "<chainID>:I:ERC20:<address>:TOKEN_RECEIVED:<asset>"
-	c.filtered = byAssetReceived
-	return nil
-}
-
-func (c *chainFilterTransfer) addByAssetSent() error {
-	c.base = "<chainID>:I:ERC20:<address>:TOKEN_SENT:<asset>"
-	c.filtered = byAssetSent
-	return nil
-}
-
-func (c *chainFilterTransfer) addByAsset(asset common.Address) error {
-	if c.filtered != "" {
-		if c.filtered != byReceived && c.filtered != bySent {
-			return fmt.Errorf("filter transfer already filtered by %s", c.filtered)
-		}
+	if options.chainID != nil {
+		query = append(query, "chainID")
+		params = append(params, *options.chainID)
 	}
-	c.asset = &asset
-	if c.filtered == byReceived {
-		return c.addByAssetReceived()
+	if options.onlyTxs {
+		query = append(query, "TX")
 	}
-	if c.filtered == bySent {
-		return c.addByAssetSent()
+	if options.onlyTransfers {
+		query = append(query, "ERC20")
 	}
-	c.base = "<chainID>:I:ERC20:<asset>:<address>:TIME"
-	c.filtered = byAsset
-	return nil
-}
-
-func (c *chainFilterTransfer) addTimeRange(from, to *timestamp.Timestamp) error {
-	if from == nil || to == nil {
-		return fmt.Errorf("invalid time range: empty border")
+	if options.method != nil {
+		query = append(query, "method")
+		params = append(params, *options.method)
 	}
-	if c.filtered == byReceived || c.filtered == bySent {
-		return fmt.Errorf("cannot apply range over filter by %s", c.filtered)
+	if options.from == nil || options.to == nil {
+		options.from = nil
+		options.to = nil
 	}
-	c.from = from
-	c.to = to
-	return nil
-}
 
-func (c *chainFilterTransfer) filterType() filterType {
-	return c.filtered
+	return &queryFilter{
+		query:    strings.Join(append(query, params...), ":"),
+		timeFrom: options.from,
+		timeTo:   options.to,
+	}, nil
 }
 
-func (c *chainFilterTransfer) valid() error {
-	if (c.from != nil || c.to != nil) && (c.filtered == bySent || c.filtered == byReceived) {
-		return fmt.Errorf("cannot apply range over filter by %s", c.filtered)
-	}
-	return nil
-}
-
-func (c *chainFilterTransfer) get(chainID string, address common.Address) string {
-	query := strings.Replace(c.base, "<chainID>", chainID, 1)
-	query = strings.Replace(query, "<address>", fmt.Sprintf("%x", address.Bytes()), 1)
-	if c.asset != nil {
-		query = strings.Replace(query, "<asset>", fmt.Sprintf("%x", c.asset.Bytes()), 1)
-	}
-	if c.to != nil {
-		query = fmt.Sprintf("%s:%s", query, reversePaddedTimestamp(c.to))
+func (f queryFilter) get(address common.Address) string {
+	query := strings.Replace(f.query, "<address>", toHex(address.Bytes()), 1)
+	if f.timeTo != nil {
+		query = fmt.Sprintf("%s:%s", query, reversePaddedTimestamp(f.timeTo))
 	}
 	return query
 }
 
-func (c *chainFilterTransfer) limit(prefix string) string {
-	if c.from != nil {
+func (f queryFilter) limit(prefix string) string {
+	if f.timeFrom != nil {
 		index := strings.LastIndex(prefix, ":")
-		return toSuccessor(fmt.Sprintf("%s:%s", prefix[:index], reversePaddedTimestamp(c.from)))
+		return toSuccessor(fmt.Sprintf("%s:%s", prefix[:index], reversePaddedTimestamp(f.timeFrom)))
 	}
 	return toSuccessor(prefix)
 }
diff --git a/backend/pkg/commons/db2/data/filter_test.go b/backend/pkg/commons/db2/data/filter_test.go
index 8bf258cd4..a31358bfe 100644
--- a/backend/pkg/commons/db2/data/filter_test.go
+++ b/backend/pkg/commons/db2/data/filter_test.go
@@ -1,139 +1,115 @@
 package data
 
 import (
+	"strings"
 	"testing"
 
 	"github.com/ethereum/go-ethereum/common"
 	"google.golang.org/protobuf/types/known/timestamppb"
 )
 
-func TestFilter(t *testing.T) {
+func TestQueryFilter(t *testing.T) {
 	tests := []struct {
-		name       string
-		filter     chainFilter
-		add        func(chainFilter) error
-		expectErr  bool
-		expectType filterType
+		name    string
+		options []Option
+		want    string
+		err     string
 	}{
 		{
-			name:   "tx by asset should err",
-			filter: newChainFilterTx(),
-			add: func(c chainFilter) error {
-				return c.addByAsset(common.Address{})
+			name: "all",
+			want: "all:<address>",
+		},
+		{
+			name: "err for ByMethod and ByAsset",
+			options: []Option{
+				ByMethod(""),
+				ByAsset(common.Address{}),
 			},
-			expectErr: true,
+			err: "cannot filter by method and by asset together",
 		},
 		{
-			name:   "tx invalid time range",
-			filter: newChainFilterTx(),
-			add: func(c chainFilter) error {
-				return c.addTimeRange(nil, nil)
+			name: "only sent",
+			options: []Option{
+				OnlySent(),
 			},
-			expectErr: true,
+			want: "out:<address>",
 		},
 		{
-			name:   "transfer by method should err",
-			filter: newChainFilterTransfer(),
-			add: func(c chainFilter) error {
-				return c.addByMethod("")
+			name: "received",
+			options: []Option{
+				OnlyReceived(),
 			},
-			expectErr: true,
+			want: "in:<address>",
 		},
 		{
-			name:   "transfer by asset sent",
-			filter: newChainFilterTransfer(),
-			add: func(c chainFilter) error {
-				if err := c.addByAsset(common.Address{}); err != nil {
-					return err
-				}
-				return c.addBySent()
+			name: "sent",
+			options: []Option{
+				OnlySent(),
 			},
-			expectType: byAssetSent,
+			want: "out:<address>",
 		},
 		{
-			name:   "transfer by asset received",
-			filter: newChainFilterTransfer(),
-			add: func(c chainFilter) error {
-				if err := c.addByAsset(common.Address{}); err != nil {
-					return err
-				}
-				return c.addByReceived()
+			name: "on a chain ID",
+			options: []Option{
+				ByChainID("1234"),
 			},
-			expectType: byAssetReceived,
+			want: "all:chainID:<address>:1234",
 		},
 		{
-			name:   "transfer by sent asset",
-			filter: newChainFilterTransfer(),
-			add: func(c chainFilter) error {
-				if err := c.addBySent(); err != nil {
-					return err
-				}
-				return c.addByAsset(common.Address{})
+			name: "sent on a chain ID",
+			options: []Option{
+				OnlySent(),
+				ByChainID("1234"),
 			},
-			expectType: byAssetSent,
+			want: "out:chainID:<address>:1234",
 		},
 		{
-			name:   "transfer by received asset",
-			filter: newChainFilterTransfer(),
-			add: func(c chainFilter) error {
-				if err := c.addByReceived(); err != nil {
-					return err
-				}
-				return c.addByAsset(common.Address{})
+			name: "received on a chain ID",
+			options: []Option{
+				OnlyReceived(),
+				ByChainID("1234"),
 			},
-			expectType: byAssetReceived,
+			want: "in:chainID:<address>:1234",
 		},
 		{
-			name:   "transfer invalid time range",
-			filter: newChainFilterTransfer(),
-			add: func(c chainFilter) error {
-				return c.addTimeRange(nil, nil)
+			name: "received TX on a chain ID",
+			options: []Option{
+				OnlyTransactions(),
+				OnlyReceived(),
+				ByChainID("1234"),
 			},
-			expectErr: true,
+			want: "in:chainID:TX:<address>:1234",
 		},
 		{
-			name:   "transfer time range over bySent should err",
-			filter: newChainFilterTransfer(),
-			add: func(c chainFilter) error {
-				if err := c.addTimeRange(timestamppb.New(t0), timestamppb.New(t0)); err != nil {
-					return err
-				}
-				if err := c.addBySent(); err != nil {
-					return err
-				}
-				return c.valid()
+			name: "received method on a chain ID",
+			options: []Option{
+				ByMethod("bar"),
+				OnlyReceived(),
+				ByChainID("1234"),
 			},
-			expectErr: true,
+			want: "in:chainID:TX:method:<address>:1234:bar",
 		},
 		{
-			name:   "transfer time range over byReceived should err",
-			filter: newChainFilterTransfer(),
-			add: func(c chainFilter) error {
-				if err := c.addTimeRange(timestamppb.New(t0), timestamppb.New(t0)); err != nil {
-					return err
-				}
-				if err := c.addByReceived(); err != nil {
-					return err
-				}
-				return c.valid()
+			name: "with time range",
+			options: []Option{
+				WithTimeRange(timestamppb.New(t0), timestamppb.New(t1)),
 			},
-			expectErr: true,
+			want: "all:<address>:" + reversePaddedTimestamp(timestamppb.New(t1)),
 		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			err := tt.add(tt.filter)
+			filter, err := newQueryFilter(apply(tt.options))
 			if err != nil {
-				if !tt.expectErr {
-					t.Errorf("unexpected err: %s", err)
+				if got, want := err.Error(), tt.err; got != want {
+					t.Errorf("got error %v, want %v", got, want)
 				}
 				return
 			}
-			if tt.expectErr {
-				t.Error("expected err but got nil")
-			}
-			if got, want := tt.filter.filterType(), tt.expectType; got != want {
-				t.Errorf("got %v, want %v", got, want)
+			addr := common.Address{}
+			query := filter.get(addr)
+			if got, want := query, strings.ReplaceAll(tt.want, "<address>", toHex(addr.Bytes())); got != want {
+				t.Errorf("get() = %v, want %v", got, want)
 			}
 		})
 	}
diff --git a/backend/pkg/commons/db2/data/keys.go b/backend/pkg/commons/db2/data/keys.go
index a039db47c..f6be0a643 100644
--- a/backend/pkg/commons/db2/data/keys.go
+++ b/backend/pkg/commons/db2/data/keys.go
@@ -11,8 +11,8 @@ import (
 )
 
 const (
-	maxInt                       = 9223372036854775807
-	maxExecutionLayerBlockNumber = 1000000000
+	maxInt = 9223372036854775807
+	// 	maxExecutionLayerBlockNumber = 1000000000
 
 	txPerBlockLimit = 10_000
 	logPerTxLimit   = 100_000
@@ -38,191 +38,139 @@ func reversePaddedTimestamp(timestamp *timestamppb.Timestamp) string {
 	return fmt.Sprintf("%019d", maxInt-timestamp.Seconds)
 }
 
-func reversedPaddedBlockNumber(blockNumber uint64) string {
-	return fmt.Sprintf("%09d", maxExecutionLayerBlockNumber-blockNumber)
-}
-
-func keyTx(chainID string, hash []byte) string {
-	format := "<chainID>:TX:<hash>"
-	replacer := strings.NewReplacer("<chainID>", chainID, "<hash>", fmt.Sprintf("%x", hash))
-	return replacer.Replace(format)
-}
-
-func keyTxSent(chainID string, tx *types.Eth1TransactionIndexed, index int) string {
-	format := "<chainID>:I:TX:<from>:TO:<to>:<time>:<index>"
-	replacer := strings.NewReplacer(
-		"<chainID>", chainID,
-		"<from>", fmt.Sprintf("%x", tx.From),
-		"<to>", fmt.Sprintf("%x", tx.To),
-		"<time>", reversePaddedTimestamp(tx.Time),
-		"<time>", reversePaddedIndex(index, txPerBlockLimit),
-	)
-	return replacer.Replace(format)
-}
+// commented for now but we will use it soon
+// func reversedPaddedBlockNumber(blockNumber uint64) string {
+//	return fmt.Sprintf("%09d", maxExecutionLayerBlockNumber-blockNumber)
+//}
 
-func keyTxReceived(chainID string, tx *types.Eth1TransactionIndexed, index int) string {
-	format := "<chainID>:I:TX:<to>:FROM:<from>:<time>:<index>"
-	replacer := strings.NewReplacer(
-		"<chainID>", chainID,
-		"<to>", fmt.Sprintf("%x", tx.To),
-		"<from>", fmt.Sprintf("%x", tx.From),
-		"<time>", reversePaddedTimestamp(tx.Time),
-		"<index>", reversePaddedIndex(index, txPerBlockLimit),
-	)
-	return replacer.Replace(format)
-}
-
-func keyTxTime(chainID string, tx *types.Eth1TransactionIndexed, address []byte, index int) string {
-	format := "<chainID>:I:TX:<address>:TIME:<time>:<index>"
-	replacer := strings.NewReplacer(
-		"<chainID>", chainID,
-		"<address>", fmt.Sprintf("%x", address),
-		"<time>", reversePaddedTimestamp(tx.Time),
-		"<index>", reversePaddedIndex(index, txPerBlockLimit),
-	)
-	return replacer.Replace(format)
-}
-
-func keyTxBlock(chainID string, tx *types.Eth1TransactionIndexed, address []byte, index int) string {
-	format := "<chainID>:I:TX:<address>:BLOCK:<block>:<index>"
-	replacer := strings.NewReplacer(
-		"<chainID>", chainID,
-		"<address>", fmt.Sprintf("%x", address),
-		"<block>", reversedPaddedBlockNumber(tx.BlockNumber),
-		"<index>", reversePaddedIndex(index, txPerBlockLimit),
-	)
-	return replacer.Replace(format)
-}
-
-func keyTxMethod(chainID string, tx *types.Eth1TransactionIndexed, address []byte, index int) string {
-	format := "<chainID>:I:TX:<address>:METHOD:<method>:<time>:<index>"
+// lost keyTxBlock, keyTxError, keyTxContractCreation
+// key are sorted side (+optional other address), chainID, type, method
+func transactionKeys(chainID string, transaction *types.Eth1TransactionIndexed, index int) (string, []string) {
+	main := "TX:<chainID>:<hash>"
+	baseKeys := []string{
+		"all:<address>",
+		"all:chainID:<address>:<chainID>",
+	}
+	fromToKeys := []string{
+		"in:<to>",
+		"in:chainID:<to>:<chainID>",
+		"in:out:<to>:<from>",
+		"in:out:chainID:<to>:<from>:<chainID>",
+		"out:<from>",
+		"out:chainID:<from>:<chainID>",
+		"out:in:<from>:<to>",
+		"out:in:chainID:<from>:<to>:<chainID>",
+	}
+	baseTxKeys := []string{
+		"all:TX:<address>",
+		"all:TX:method:<address>:<method>",
+		"all:chainID:TX:<address>:<chainID>",
+		"all:chainID:TX:method:<address>:<chainID>:<method>",
+	}
+	fromToTxKeys := []string{
+		"in:TX:<to>",
+		"in:TX:method:<to>:<method>",
+		"in:chainID:TX:<to>:<chainID>",
+		"in:chainID:TX:method:<to>:<chainID>:<method>",
+		"in:out:TX:<to>:<from>",
+		"in:out:TX:method:<to>:<from>:<method>",
+		"in:out:chainID:TX:<to>:<from>:<chainID>",
+		"in:out:chainID:TX:method:<to>:<from>:<chainID>:<method>",
+		"out:TX:<from>",
+		"out:TX:method:<from>:<method>",
+		"out:chainID:TX:<from>:<chainID>",
+		"out:chainID:TX:method:<from>:<chainID>:<method>",
+		"out:in:TX:<from>:<to>",
+		"out:in:TX:method:<from>:<to>:<method>",
+		"out:in:chainID:TX:<from>:<to>:<chainID>",
+		"out:in:chainID:TX:method:<from>:<to>:<chainID>:<method>",
+	}
 	replacer := strings.NewReplacer(
+		"<hash>", toHex(transaction.Hash),
+		"<from>", toHex(transaction.From),
+		"<to>", toHex(transaction.To),
 		"<chainID>", chainID,
-		"<address>", fmt.Sprintf("%x", address),
-		"<method>", fmt.Sprintf("%x", tx.MethodId),
-		"<time>", reversePaddedTimestamp(tx.Time),
+		"<time>", reversePaddedTimestamp(transaction.Time),
 		"<index>", reversePaddedIndex(index, txPerBlockLimit),
+		"<method>", fmt.Sprintf("%x", transaction.MethodId),
 	)
-	return replacer.Replace(format)
-}
+	keys := append(fromToKeys, fromToTxKeys...)
+	for _, format := range append(baseKeys, baseTxKeys...) {
+		keys = append(keys,
+			strings.ReplaceAll(format, "<address>", "<from>"),
+			strings.ReplaceAll(format, "<address>", "<to>"),
+		)
+	}
+	id := ":<time>:<index>"
+	for i := range keys {
+		keys[i] = replacer.Replace(keys[i] + id)
+	}
 
-func keyTxError(chainID string, tx *types.Eth1TransactionIndexed, address []byte, index int) string {
-	format := "<chainID>:I:TX:<address>:ERROR:<time>:<index>"
-	replacer := strings.NewReplacer(
-		"<chainID>", chainID,
-		"<address>", fmt.Sprintf("%x", address),
-		"<time>", reversePaddedTimestamp(tx.Time),
-		"<index>", reversePaddedIndex(index, txPerBlockLimit),
-	)
-	return replacer.Replace(format)
+	return replacer.Replace(main), keys
 }
 
-func keyTxContractCreation(chainID string, tx *types.Eth1TransactionIndexed, address []byte, index int) string {
-	format := "<chainID>:I:TX:<address>:CONTRACT:<time>:<index>"
+// key are sorted side (+optional other address), chainID, type, asset
+func transferKeys(chainID string, transaction *types.Eth1ERC20Indexed, index int, logIndex int) (string, []string) {
+	main := "ERC20:<chainID>:<hash>"
+	baseKeys := []string{
+		"all:<address>",
+		"all:chainID:<address>:<chainID>",
+	}
+	fromToKeys := []string{
+		"in:<to>",
+		"in:chainID:<to>:<chainID>",
+		"in:out:<to>:<from>",
+		"in:out:chainID:<to>:<from>:<chainID>",
+		"out:<from>",
+		"out:chainID:<from>:<chainID>",
+		"out:in:<from>:<to>",
+		"out:in:chainID:<from>:<to>:<chainID>",
+	}
+	baseTxKeys := []string{
+		"all:ERC20:<address>",
+		"all:ERC20:asset:<address>:<asset>",
+		"all:chainID:ERC20:<address>:<chainID>",
+		"all:chainID:ERC20:asset:<address>:<chainID>:<asset>",
+	}
+	fromToTxKeys := []string{
+		"in:ERC20:<to>",
+		"in:ERC20:asset:<to>:<asset>",
+		"in:chainID:ERC20:<to>:<chainID>",
+		"in:chainID:ERC20:asset:<to>:<chainID>:<asset>",
+		"in:out:ERC20:<to>:<from>",
+		"in:out:ERC20:asset:<to>:<from>:<asset>",
+		"in:out:chainID:ERC20:<to>:<from>:<chainID>",
+		"in:out:chainID:ERC20:asset:<to>:<from>:<chainID>:<asset>",
+		"out:ERC20:<from>",
+		"out:ERC20:asset:<from>:<asset>",
+		"out:chainID:ERC20:<from>:<chainID>",
+		"out:chainID:ERC20:asset:<from>:<chainID>:<asset>",
+		"out:in:ERC20:<from>:<to>",
+		"out:in:ERC20:asset:<from>:<to>:<asset>",
+		"out:in:chainID:ERC20:<from>:<to>:<chainID>",
+		"out:in:chainID:ERC20:asset:<from>:<to>:<chainID>:<asset>",
+	}
 	replacer := strings.NewReplacer(
+		"<hash>", toHex(transaction.ParentHash),
+		"<from>", toHex(transaction.From),
+		"<to>", toHex(transaction.To),
 		"<chainID>", chainID,
-		"<address>", fmt.Sprintf("%x", address),
-		"<time>", reversePaddedTimestamp(tx.Time),
+		"<time>", reversePaddedTimestamp(transaction.Time),
 		"<index>", reversePaddedIndex(index, txPerBlockLimit),
-	)
-	return replacer.Replace(format)
-}
-
-func keyERC20(chainID string, hash []byte, logIndex int) string {
-	format := "<chainID>:ERC20:<hash>:<logIndex>"
-	replacer := strings.NewReplacer(
-		"<chainID>", chainID,
-		"<hash>", fmt.Sprintf("%x", hash),
-		"<logIndex>", reversePaddedIndex(logIndex, logPerTxLimit),
-	)
-	return replacer.Replace(format)
-}
-
-func keyERC20Time(chainID string, tx *types.Eth1ERC20Indexed, address []byte, txIndex int, logIndex int) string {
-	format := "<chainID>:I:ERC20:<address>:TIME:<time>:<index>:<logIndex>"
-	replacer := strings.NewReplacer(
-		"<chainID>", chainID,
-		"<address>", fmt.Sprintf("%x", address),
-		"<time>", reversePaddedTimestamp(tx.Time),
-		"<index>", reversePaddedIndex(txIndex, txPerBlockLimit),
-		"<logIndex>", reversePaddedIndex(logIndex, logPerTxLimit),
-	)
-	return replacer.Replace(format)
-}
-
-func keyERC20ContractAllTime(chainID string, tx *types.Eth1ERC20Indexed, txIndex int, logIndex int) string {
-	format := "<chainID>:I:ERC20:<contract>:ALL:TIME:<time>:<index>:<logIndex>"
-	replacer := strings.NewReplacer(
-		"<chainID>", chainID,
-		"<contract>", fmt.Sprintf("%x", tx.TokenAddress),
-		"<time>", reversePaddedTimestamp(tx.Time),
-		"<index>", reversePaddedIndex(txIndex, txPerBlockLimit),
-		"<logIndex>", reversePaddedIndex(logIndex, logPerTxLimit),
-	)
-	return replacer.Replace(format)
-}
-
-func keyERC20ContractTime(chainID string, tx *types.Eth1ERC20Indexed, address []byte, txIndex int, logIndex int) string {
-	format := "<chainID>:I:ERC20:<contract>:<address>:TIME:<time>:<index>:<logIndex>"
-	replacer := strings.NewReplacer(
-		"<chainID>", chainID,
-		"<contract>", fmt.Sprintf("%x", tx.TokenAddress),
-		"<address>", fmt.Sprintf("%x", address),
-		"<time>", reversePaddedTimestamp(tx.Time),
-		"<index>", reversePaddedIndex(txIndex, txPerBlockLimit),
-		"<logIndex>", reversePaddedIndex(logIndex, logPerTxLimit),
-	)
-	return replacer.Replace(format)
-}
-
-func keyERC20To(chainID string, tx *types.Eth1ERC20Indexed, txIndex int, logIndex int) string {
-	format := "<chainID>:I:ERC20:<from>:TO:<to>:<time>:<index>:<logIndex>"
-	replacer := strings.NewReplacer(
-		"<chainID>", chainID,
-		"<from>", fmt.Sprintf("%x", tx.From),
-		"<to>", fmt.Sprintf("%x", tx.To),
-		"<time>", reversePaddedTimestamp(tx.Time),
-		"<index>", reversePaddedIndex(txIndex, txPerBlockLimit),
-		"<logIndex>", reversePaddedIndex(logIndex, logPerTxLimit),
-	)
-	return replacer.Replace(format)
-}
-
-func keyERC20From(chainID string, tx *types.Eth1ERC20Indexed, txIndex int, logIndex int) string {
-	format := "<chainID>:I:ERC20:<to>:FROM:<from>:<time>:<index>:<logIndex>"
-	replacer := strings.NewReplacer(
-		"<chainID>", chainID,
-		"<to>", fmt.Sprintf("%x", tx.To),
-		"<from>", fmt.Sprintf("%x", tx.From),
-		"<time>", reversePaddedTimestamp(tx.Time),
-		"<index>", reversePaddedIndex(txIndex, txPerBlockLimit),
-		"<logIndex>", reversePaddedIndex(logIndex, logPerTxLimit),
-	)
-	return replacer.Replace(format)
-}
-
-func keyERC20Sent(chainID string, tx *types.Eth1ERC20Indexed, txIndex int, logIndex int) string {
-	format := "<chainID>:I:ERC20:<from>:TOKEN_SENT:<contract>:<time>:<index>:<logIndex>"
-	replacer := strings.NewReplacer(
-		"<chainID>", chainID,
-		"<from>", fmt.Sprintf("%x", tx.From),
-		"<contract>", fmt.Sprintf("%x", tx.TokenAddress),
-		"<time>", reversePaddedTimestamp(tx.Time),
-		"<index>", reversePaddedIndex(txIndex, txPerBlockLimit),
 		"<logIndex>", reversePaddedIndex(logIndex, logPerTxLimit),
+		"<asset>", toHex(transaction.TokenAddress),
 	)
-	return replacer.Replace(format)
-}
+	keys := append(fromToKeys, fromToTxKeys...)
+	for _, format := range append(baseKeys, baseTxKeys...) {
+		keys = append(keys,
+			strings.ReplaceAll(format, "<address>", "<from>"),
+			strings.ReplaceAll(format, "<address>", "<to>"),
+		)
+	}
+	id := ":<time>:<index>:<logIndex>"
+	for i := range keys {
+		keys[i] = replacer.Replace(keys[i] + id)
+	}
 
-func keyERC20Received(chainID string, tx *types.Eth1ERC20Indexed, txIndex int, logIndex int) string {
-	format := "<chainID>:I:ERC20:<to>:TOKEN_RECEIVED:<contract>:<time>:<index>:<logIndex>"
-	replacer := strings.NewReplacer(
-		"<chainID>", chainID,
-		"<to>", fmt.Sprintf("%x", tx.To),
-		"<contract>", fmt.Sprintf("%x", tx.TokenAddress),
-		"<time>", reversePaddedTimestamp(tx.Time),
-		"<index>", reversePaddedIndex(txIndex, txPerBlockLimit),
-		"<logIndex>", reversePaddedIndex(logIndex, logPerTxLimit),
-	)
-	return replacer.Replace(format)
+	return replacer.Replace(main), keys
 }
diff --git a/backend/pkg/commons/db2/data/option.go b/backend/pkg/commons/db2/data/option.go
index f28210c9b..c1b69f779 100644
--- a/backend/pkg/commons/db2/data/option.go
+++ b/backend/pkg/commons/db2/data/option.go
@@ -1,10 +1,10 @@
 package data
 
 import (
-	"fmt"
-
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/golang/protobuf/ptypes/timestamp"
+
+	"github.com/gobitfly/beaconchain/pkg/commons/db2/database"
 )
 
 type Option interface {
@@ -12,13 +12,15 @@ type Option interface {
 }
 
 type options struct {
-	from, to        *timestamp.Timestamp
-	method          *string
-	ignoreTxs       bool
-	ignoreTransfers bool
-	onlySent        bool
-	onlyReceived    bool
-	asset           *common.Address
+	from, to      *timestamp.Timestamp
+	method        *string
+	chainID       *string
+	onlySent      bool
+	onlyReceived  bool
+	asset         *common.Address
+	onlyTxs       bool
+	onlyTransfers bool
+	statsReporter func(msg string, args ...any)
 }
 
 func apply(opts []Option) options {
@@ -43,36 +45,44 @@ func (r byTimeRangeOption) apply(opts *options) {
 	opts.to = r.to
 }
 
-type byMethodOption struct {
-	method string
-}
+type byMethodOption string
 
 func ByMethod(method string) Option {
-	return byMethodOption{method: method}
+	return byMethodOption(method)
 }
 
 func (r byMethodOption) apply(opts *options) {
-	opts.method = &r.method
+	opts.method = (*string)(&r)
 }
 
-type ignoreTransactionsOption bool
+type byChainIDOption string
 
-func IgnoreTransactions() Option {
-	return ignoreTransactionsOption(true)
+func ByChainID(chainID string) Option {
+	return byChainIDOption(chainID)
 }
 
-func (r ignoreTransactionsOption) apply(opts *options) {
-	opts.ignoreTxs = bool(r)
+func (r byChainIDOption) apply(opts *options) {
+	opts.chainID = (*string)(&r)
 }
 
-type ignoreTransfersOption bool
+type onlyTransactionsOption bool
 
-func IgnoreTransfers() Option {
-	return ignoreTransfersOption(true)
+func OnlyTransactions() Option {
+	return onlyTransactionsOption(true)
 }
 
-func (r ignoreTransfersOption) apply(opts *options) {
-	opts.ignoreTransfers = bool(r)
+func (r onlyTransactionsOption) apply(opts *options) {
+	opts.onlyTxs = bool(r)
+}
+
+type onlyTransfersOption bool
+
+func OnlyTransfers() Option {
+	return onlyTransfersOption(true)
+}
+
+func (r onlyTransfersOption) apply(opts *options) {
+	opts.onlyTransfers = bool(r)
 }
 
 type onlySentOption bool
@@ -107,48 +117,12 @@ func (r byAssetOption) apply(opts *options) {
 	opts.asset = &r.asset
 }
 
-func makeFilters(options options, typeFilter formatType) (filter, error) {
-	var f chainFilter
-	switch typeFilter {
-	case typeTx:
-		f = newChainFilterTx()
-	case typeTransfer:
-		f = newChainFilterTransfer()
-	default:
-		return nil, fmt.Errorf("unknown filter type: %s", typeFilter)
-	}
-	if options.onlyReceived && options.onlySent {
-		options.onlyReceived = false
-		options.onlySent = false
-	}
-	if options.onlySent {
-		if err := f.addBySent(); err != nil {
-			return nil, err
-		}
-	}
-	if options.onlyReceived {
-		if err := f.addByReceived(); err != nil {
-			return nil, err
-		}
-	}
-	if options.method != nil {
-		if err := f.addByMethod(*options.method); err != nil {
-			return nil, err
-		}
-	}
-	if options.asset != nil {
-		if err := f.addByAsset(*options.asset); err != nil {
-			return nil, err
-		}
-	}
-	if options.from != nil && options.to != nil {
-		if err := f.addTimeRange(options.from, options.to); err != nil {
-			return nil, err
-		}
-	}
-	if err := f.valid(); err != nil {
-		return nil, err
-	}
+type withDatabaseStatsOption database.StatsReporter
+
+func WithDatabaseStats(reporter database.StatsReporter) Option {
+	return withDatabaseStatsOption(reporter)
+}
 
-	return f, nil
+func (r withDatabaseStatsOption) apply(opts *options) {
+	opts.statsReporter = r
 }
diff --git a/backend/pkg/commons/db2/data/parser.go b/backend/pkg/commons/db2/data/parser.go
new file mode 100644
index 000000000..d7f4522f9
--- /dev/null
+++ b/backend/pkg/commons/db2/data/parser.go
@@ -0,0 +1,58 @@
+package data
+
+import (
+	"fmt"
+
+	"google.golang.org/protobuf/proto"
+
+	"github.com/gobitfly/beaconchain/pkg/commons/db2/database"
+	"github.com/gobitfly/beaconchain/pkg/commons/types"
+)
+
+func BlockTransactionsToItemsV2(chainID string, transactions []*types.Eth1TransactionIndexed) (map[string][]database.Item, error) {
+	if len(transactions) > txPerBlockLimit {
+		return nil, fmt.Errorf("unexpected number of transactions in block expected at most %d but got: %v, chainID: %s, block: %d", txPerBlockLimit, len(transactions), chainID, transactions[0].BlockNumber)
+	}
+
+	items := make(map[string][]database.Item)
+	for i, transaction := range transactions {
+		b, err := proto.Marshal(transaction)
+		if err != nil {
+			return nil, err
+		}
+		key, indexes := transactionKeys(chainID, transaction, i)
+		items[key] = []database.Item{{Family: defaultFamily, Column: dataColumn, Data: b}}
+		for _, index := range indexes {
+			items[index] = []database.Item{{Family: defaultFamily, Column: key}}
+		}
+	}
+	return items, nil
+}
+
+func BlockERC20TransfersToItemsV2(chainID string, transfers []TransferWithIndexes) (map[string][]database.Item, error) {
+	items := make(map[string][]database.Item)
+	for _, transfer := range transfers {
+		if transfer.TxIndex > txPerBlockLimit {
+			return nil, fmt.Errorf("unexpected number of transactions in block expected at most %d but got: %v, chainID: %s, block: %d", txPerBlockLimit, transfer.TxIndex, chainID, transfers[0].Indexed.BlockNumber)
+		}
+		if transfer.LogIndex > logPerTxLimit {
+			return nil, fmt.Errorf("unexpected number of logs in block expected at most %d but got: %v, chainID: %s, block: %d", logPerTxLimit, transfer.LogIndex, chainID, transfers[0].Indexed.BlockNumber)
+		}
+		b, err := proto.Marshal(transfer.Indexed)
+		if err != nil {
+			return nil, err
+		}
+		key, indexes := transferKeys(chainID, transfer.Indexed, transfer.TxIndex, transfer.LogIndex)
+		items[key] = []database.Item{{Family: defaultFamily, Column: dataColumn, Data: b}}
+		for _, index := range indexes {
+			items[index] = []database.Item{{Family: defaultFamily, Column: key}}
+		}
+	}
+	return items, nil
+}
+
+type TransferWithIndexes struct {
+	Indexed  *types.Eth1ERC20Indexed
+	TxIndex  int
+	LogIndex int
+}
diff --git a/backend/pkg/commons/db2/database/bigtable.go b/backend/pkg/commons/db2/database/bigtable.go
index 7843410ee..3180042b4 100644
--- a/backend/pkg/commons/db2/database/bigtable.go
+++ b/backend/pkg/commons/db2/database/bigtable.go
@@ -4,9 +4,11 @@ import (
 	"context"
 	"fmt"
 	"slices"
+	"sort"
 	"time"
 
 	"cloud.google.com/go/bigtable"
+	"google.golang.org/api/option"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
 )
@@ -60,8 +62,8 @@ func (w TableWrapper) GetRowKeys(prefix string, opts ...Option) ([]string, error
 	return w.BigTable.GetRowKeys(w.table, prefix, opts...)
 }
 
-func (w TableWrapper) BulkAdd(itemsByKey map[string][]Item) error {
-	return w.BigTable.BulkAdd(w.table, itemsByKey)
+func (w TableWrapper) BulkAdd(itemsByKey map[string][]Item, opts ...Option) error {
+	return w.BigTable.BulkAdd(w.table, itemsByKey, opts...)
 }
 
 func (w TableWrapper) GetRowsRange(high, low string, opts ...Option) ([]Row, error) {
@@ -89,18 +91,18 @@ func NewBigTableWithClient(ctx context.Context, client *bigtable.Client, adminCl
 
 // NewBigTable initializes a new BigTable
 // It returns a BigTable and an error if any part of the setup fails
-func NewBigTable(project, instance string, tablesAndFamilies map[string][]string) (*BigTable, error) {
+func NewBigTable(project, instance string, tablesAndFamilies map[string][]string, options ...option.ClientOption) (*BigTable, error) {
 	ctx, cancel := context.WithTimeout(context.Background(), timeout)
 	defer cancel()
 
 	// Create an admin client to manage Bigtable tables
-	adminClient, err := bigtable.NewAdminClient(ctx, project, instance)
+	adminClient, err := bigtable.NewAdminClient(ctx, project, instance, options...)
 	if err != nil {
 		return nil, fmt.Errorf("could not create admin client: %v", err)
 	}
 
 	// Create a Bigtable client for performing data operations
-	client, err := bigtable.NewClient(ctx, project, instance)
+	client, err := bigtable.NewClient(ctx, project, instance, options...)
 	if err != nil {
 		return nil, fmt.Errorf("could not create data operations client: %v", err)
 	}
@@ -149,7 +151,9 @@ func createTableAndFamilies(ctx context.Context, admin *bigtable.AdminClient, ta
 	return nil
 }
 
-func (b BigTable) BulkAdd(table string, itemsByKey map[string][]Item) error {
+func (b BigTable) BulkAdd(table string, itemsByKey map[string][]Item, opts ...Option) error {
+	options := apply(opts)
+
 	tbl := b.client.Open(table)
 	ctx, cancel := context.WithTimeout(context.Background(), timeout)
 	defer cancel()
@@ -164,16 +168,27 @@ func (b BigTable) BulkAdd(table string, itemsByKey map[string][]Item) error {
 		keys = append(keys, key)
 		muts = append(muts, mut)
 	}
-	errs, err := tbl.ApplyBulk(ctx, keys, muts)
-	if err != nil {
-		return fmt.Errorf("cannot ApplyBulk err: %w", err)
-	}
-	var bulkErrs []string
-	for _, err := range errs {
-		bulkErrs = append(bulkErrs, err.Error())
+	bulk := &bulkMutations{
+		Keys: keys,
+		Muts: muts,
 	}
-	if len(bulkErrs) > 0 {
-		return fmt.Errorf("cannot BulkAdd errors: %v", bulkErrs)
+	sort.Sort(bulk)
+	for i := int64(0); i < int64(bulk.Len()); i = i + options.BatchSize {
+		from, to := i, i+options.BatchSize
+		if to > int64(bulk.Len()) {
+			to = int64(bulk.Len())
+		}
+		errs, err := tbl.ApplyBulk(ctx, bulk.Keys[from:to], bulk.Muts[from:to])
+		if err != nil {
+			return fmt.Errorf("cannot ApplyBulk err: %w", err)
+		}
+		var bulkErrs []string
+		for _, err := range errs {
+			bulkErrs = append(bulkErrs, err.Error())
+		}
+		if len(bulkErrs) > 0 {
+			return fmt.Errorf("cannot BulkAdd errors: %v", bulkErrs)
+		}
 	}
 	return nil
 }
@@ -301,6 +316,7 @@ func (b BigTable) GetRowsRange(table, high, low string, opts ...Option) ([]Row,
 	if options.OpenCloseRange {
 		rowRange = bigtable.NewOpenClosedRange(low, high)
 	}
+	readOptions := bigtableReadOptions(options, rowRange)
 	var data []Row
 	err := tbl.ReadRows(ctx, rowRange, func(row bigtable.Row) bool {
 		values := make(map[string][]byte)
@@ -314,8 +330,7 @@ func (b BigTable) GetRowsRange(table, high, low string, opts ...Option) ([]Row,
 			Values: values,
 		})
 		return true
-	}, bigtable.LimitRows(options.Limit))
-
+	}, readOptions...)
 	if err != nil {
 		return nil, fmt.Errorf("could not read rows: %v", err)
 	}
@@ -333,13 +348,13 @@ func (b BigTable) GetRowKeys(table, prefix string, opts ...Option) ([]string, er
 	ctx, cancel := context.WithTimeout(context.Background(), timeout)
 	defer cancel()
 
+	rowRange := bigtable.PrefixRange(prefix)
+	readOptions := bigtableReadOptions(options, bigtable.PrefixRange(prefix))
 	var data []string
-	// Read all rows from the table and collect all the row keys
-	err := tbl.ReadRows(ctx, bigtable.PrefixRange(prefix), func(row bigtable.Row) bool {
+	err := tbl.ReadRows(ctx, rowRange, func(row bigtable.Row) bool {
 		data = append(data, row.Key())
 		return true
-	}, bigtable.LimitRows(options.Limit))
-
+	}, readOptions...)
 	if err != nil {
 		return nil, fmt.Errorf("could not read rows: %v", err)
 	}
@@ -409,3 +424,48 @@ func (b BigTable) Close() error {
 	}
 	return nil
 }
+
+type bulkMutations struct {
+	Keys []string
+	Muts []*bigtable.Mutation
+}
+
+func (bulkMutations *bulkMutations) Len() int {
+	return len(bulkMutations.Keys)
+}
+
+func (bulkMutations *bulkMutations) Less(i, j int) bool {
+	return bulkMutations.Keys[i] < bulkMutations.Keys[j]
+}
+
+func (bulkMutations *bulkMutations) Swap(i, j int) {
+	bulkMutations.Keys[i], bulkMutations.Keys[j] = bulkMutations.Keys[j], bulkMutations.Keys[i]
+	bulkMutations.Muts[i], bulkMutations.Muts[j] = bulkMutations.Muts[j], bulkMutations.Muts[i]
+}
+
+const (
+	KeyStatRange        = "range"
+	KeyStatRowsSeen     = "rowsSeen"
+	KeyStatRowsReturned = "rowsReturned"
+	KeyStatEfficiency   = "efficiency"
+)
+
+func bigtableReadOptions(options options, rowRange bigtable.RowRange) []bigtable.ReadOption {
+	readOptions := []bigtable.ReadOption{bigtable.LimitRows(options.Limit)}
+	if options.StatsReporter != nil {
+		readOptions = append(readOptions, bigtable.WithFullReadStats(func(stats *bigtable.FullReadStats) {
+			efficiency := int64(1)
+			if stats.ReadIterationStats.RowsSeenCount != 0 {
+				efficiency = stats.ReadIterationStats.RowsReturnedCount / stats.ReadIterationStats.RowsSeenCount
+			}
+			options.StatsReporter(
+				"query stats",
+				KeyStatRange, rowRange.String(),
+				KeyStatRowsSeen, stats.ReadIterationStats.RowsSeenCount,
+				KeyStatRowsReturned, stats.ReadIterationStats.RowsReturnedCount,
+				KeyStatEfficiency, efficiency,
+			)
+		}))
+	}
+	return readOptions
+}
diff --git a/backend/pkg/commons/db2/database/bigtable_test.go b/backend/pkg/commons/db2/database/bigtable_test.go
index a4dde2233..e2b811f56 100644
--- a/backend/pkg/commons/db2/database/bigtable_test.go
+++ b/backend/pkg/commons/db2/database/bigtable_test.go
@@ -5,15 +5,45 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"reflect"
 	"slices"
 	"strings"
 	"testing"
 
+	"cloud.google.com/go/bigtable/bttest"
 	"golang.org/x/exp/maps"
+	"google.golang.org/api/option"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials/insecure"
 
 	"github.com/gobitfly/beaconchain/pkg/commons/db2/databasetest"
 )
 
+func TestNewBigTable(t *testing.T) {
+	srv, err := bttest.NewServer("localhost:0")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	conn, err := grpc.NewClient(srv.Addr, grpc.WithTransportCredentials(insecure.NewCredentials()))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	testTable, testFamily := "table", "family"
+	bt, err := NewBigTable("testProject", "testInstance", map[string][]string{testTable: {testFamily}}, option.WithGRPCConn(conn))
+	if err != nil {
+		t.Fatal(err)
+	}
+	tableInfo, err := bt.admin.TableInfo(context.Background(), testTable)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got, want := tableInfo.Families, []string{testFamily}; !reflect.DeepEqual(got, want) {
+		t.Errorf("got %v, want %v", got, want)
+	}
+}
+
 func TestBigTable(t *testing.T) {
 	tests := []struct {
 		name     string
@@ -71,7 +101,7 @@ func TestBigTable(t *testing.T) {
 				_ = db.Clear()
 			}()
 
-			if err := db.BulkAdd(tt.items); err != nil {
+			if err := db.BulkAdd(tt.items, WithBatchSize(2)); err != nil {
 				t.Error(err)
 			}
 
@@ -216,6 +246,12 @@ func TestGetRowsRange(t *testing.T) {
 			expected: 5,
 			options:  []Option{WithLimit(5)},
 		},
+		{
+			name:     "with stats",
+			txs:      1,
+			expected: 1,
+			options:  []Option{WithStats(func(msg string, args ...any) {})},
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
diff --git a/backend/pkg/commons/db2/database/option.go b/backend/pkg/commons/db2/database/option.go
index 58d352a49..8237529ad 100644
--- a/backend/pkg/commons/db2/database/option.go
+++ b/backend/pkg/commons/db2/database/option.go
@@ -1,13 +1,25 @@
 package database
 
+const (
+	defaultBatchSize = 10000
+	defaultLimit     = 100
+)
+
 type options struct {
 	OpenRange      bool
 	OpenCloseRange bool
 	Limit          int64
+	BatchSize      int64
+	StatsReporter  func(msg string, args ...any)
 }
 
 func apply(opts []Option) options {
-	options := options{}
+	options := options{
+		OpenRange:      false,
+		OpenCloseRange: false,
+		BatchSize:      defaultBatchSize,
+		Limit:          defaultLimit,
+	}
 	for _, o := range opts {
 		o.apply(&options)
 	}
@@ -47,3 +59,25 @@ func (l limitOption) apply(opts *options) {
 func WithLimit(l int64) Option {
 	return limitOption(l)
 }
+
+type withBatchSize int64
+
+func (l withBatchSize) apply(opts *options) {
+	opts.BatchSize = int64(l)
+}
+
+func WithBatchSize(l int64) Option {
+	return withBatchSize(l)
+}
+
+type statsOption StatsReporter
+
+func (l statsOption) apply(opts *options) {
+	opts.StatsReporter = l
+}
+
+func WithStats(reporter StatsReporter) Option {
+	return statsOption(reporter)
+}
+
+type StatsReporter func(msg string, args ...any)
diff --git a/backend/pkg/commons/db2/database/remote.go b/backend/pkg/commons/db2/database/remote.go
index d201134c1..a0c061b4f 100644
--- a/backend/pkg/commons/db2/database/remote.go
+++ b/backend/pkg/commons/db2/database/remote.go
@@ -136,7 +136,7 @@ func (r RemoteClient) Add(key string, item Item, allowDuplicate bool) error {
 	panic("implement me")
 }
 
-func (r RemoteClient) BulkAdd(itemsByKey map[string][]Item) error {
+func (r RemoteClient) BulkAdd(itemsByKey map[string][]Item, opts ...Option) error {
 	//TODO implement me
 	panic("implement me")
 }
diff --git a/backend/pkg/commons/db2/database/store.go b/backend/pkg/commons/db2/database/store.go
index 5e782362f..a6a8549b4 100644
--- a/backend/pkg/commons/db2/database/store.go
+++ b/backend/pkg/commons/db2/database/store.go
@@ -2,7 +2,7 @@ package database
 
 type Database interface {
 	Add(key string, item Item, allowDuplicate bool) error
-	BulkAdd(itemsByKey map[string][]Item) error
+	BulkAdd(itemsByKey map[string][]Item, opts ...Option) error
 	Read(prefix string) ([]Row, error)
 	GetRow(key string) (*Row, error)
 	GetRowsWithKeys(keys []string) ([]Row, error)
diff --git a/backend/pkg/commons/db2/databasetest/bigtable.go b/backend/pkg/commons/db2/databasetest/bigtable.go
index d734df661..9ef66d88a 100644
--- a/backend/pkg/commons/db2/databasetest/bigtable.go
+++ b/backend/pkg/commons/db2/databasetest/bigtable.go
@@ -18,6 +18,7 @@ func NewBigTable(t testing.TB) (*bigtable.Client, *bigtable.AdminClient) {
 		t.Fatal(err)
 	}
 	ctx := context.Background()
+	t.Cleanup(func() { srv.Close() })
 
 	conn, err := grpc.NewClient(srv.Addr, grpc.WithTransportCredentials(insecure.NewCredentials()))
 	if err != nil {
diff --git a/backend/pkg/commons/db2/metadata/key.go b/backend/pkg/commons/db2/metadata/key.go
new file mode 100644
index 000000000..2fee0ecbf
--- /dev/null
+++ b/backend/pkg/commons/db2/metadata/key.go
@@ -0,0 +1,54 @@
+package metadata
+
+import (
+	"fmt"
+
+	"github.com/gobitfly/beaconchain/pkg/commons/db2/database"
+	"github.com/gobitfly/beaconchain/pkg/commons/utils"
+)
+
+const (
+	METADATA_UPDATES_FAMILY_BLOCKS = "blocks"
+	maxExecutionLayerBlockNumber   = 1000000000
+	DEFAULT_FAMILY                 = "f"
+)
+
+type Cache interface {
+	Set(key, value []byte, expireSeconds int) (err error)
+	Get(key []byte) (value []byte, err error)
+}
+
+// todo proper implement this function - Tangui
+func BlockKeysMutation(chainID string, blockNumber uint64, blockHash []byte, keys string) map[string][]database.Item {
+	items := make(map[string][]database.Item)
+	key := fmt.Sprintf("%s:BLOCK:%s:%x", chainID, reversedPaddedBlockNumber(blockNumber), blockHash)
+	items[key] = []database.Item{
+		{
+			Family: METADATA_UPDATES_FAMILY_BLOCKS,
+			Column: "keys",
+			Data:   []byte(keys),
+		},
+	}
+	return items
+}
+
+func MarkBalanceUpdate(chainID string, address []byte, token []byte, cache Cache) map[string][]database.Item {
+	items := make(map[string][]database.Item)
+
+	key := fmt.Sprintf("%s:B:%x", chainID, address) // format is B: for balance update as chainid:prefix:address (token id will be encoded as column name)
+	keyCache := []byte(fmt.Sprintf("%s:B:%x:%x", chainID, address, token))
+	if _, err := cache.Get(keyCache); err != nil {
+		items[key] = []database.Item{
+			{
+				Family: DEFAULT_FAMILY,
+				Column: fmt.Sprintf("%x", token),
+			},
+		}
+		_ = cache.Set(keyCache, []byte{0x1}, int((utils.Day * 2).Seconds()))
+	}
+	return items
+}
+
+func reversedPaddedBlockNumber(blockNumber uint64) string {
+	return fmt.Sprintf("%09d", maxExecutionLayerBlockNumber-blockNumber)
+}
diff --git a/backend/pkg/commons/indexer/cache.go b/backend/pkg/commons/indexer/cache.go
new file mode 100644
index 000000000..07f29f60a
--- /dev/null
+++ b/backend/pkg/commons/indexer/cache.go
@@ -0,0 +1,15 @@
+package indexer
+
+import (
+	"fmt"
+)
+
+type NoopCache struct{}
+
+func (n NoopCache) Set(key, value []byte, expireSeconds int) error {
+	return nil
+}
+
+func (n NoopCache) Get(key []byte) ([]byte, error) {
+	return nil, fmt.Errorf("noopCache")
+}
diff --git a/backend/pkg/commons/indexer/indexer.go b/backend/pkg/commons/indexer/indexer.go
new file mode 100644
index 000000000..e5ef6234d
--- /dev/null
+++ b/backend/pkg/commons/indexer/indexer.go
@@ -0,0 +1,67 @@
+package indexer
+
+import (
+	"fmt"
+	"strings"
+
+	"golang.org/x/exp/maps"
+
+	"github.com/gobitfly/beaconchain/pkg/commons/db2/data"
+	"github.com/gobitfly/beaconchain/pkg/commons/db2/database"
+	"github.com/gobitfly/beaconchain/pkg/commons/db2/metadata"
+	"github.com/gobitfly/beaconchain/pkg/commons/types"
+)
+
+type TransformFunc func(chainID string, blk *types.Eth1Block) (map[string][]database.Item, map[string][]database.Item, error)
+
+type Indexer struct {
+	store        data.Store
+	transformers []TransformFunc
+}
+
+func New(store data.Store, transformers ...TransformFunc) *Indexer {
+	return &Indexer{
+		store:        store,
+		transformers: transformers,
+	}
+}
+
+func (indexer *Indexer) IndexBlocksWithTransformers(chainID string, blocks []*types.Eth1Block) error {
+	updates := make(map[string][]database.Item)
+	updatesMetadata := make(map[string][]database.Item)
+	for _, block := range blocks {
+		for _, transform := range indexer.transformers {
+			update, updateMetadata, err := transform(chainID, block)
+			if err != nil {
+				return fmt.Errorf("error transforming block [%v]", block.Number)
+			}
+			maps.Copy(updates, update)
+
+			if updateMetadata != nil {
+				maps.Copy(updatesMetadata, updateMetadata)
+			}
+
+			if len(update) > 0 {
+				metaKeys := strings.Join(maps.Keys(update), ",") // save block keys in order to be able to handle chain reorgs
+				maps.Copy(updatesMetadata, metadata.BlockKeysMutation(chainID, block.Number, block.Hash, metaKeys))
+			}
+		}
+	}
+
+	if len(updates) > 0 {
+		err := indexer.store.AddItems(updates)
+		if err != nil {
+			return fmt.Errorf("error writing blocks [%v-%v] to bigtable data table: %w", blocks[0].Number, blocks[len(blocks)-1].Number, err)
+		}
+	}
+
+	// todo
+	/*	if len(bulkMutsMetadataUpdate.Keys) > 0 {
+		err := bigtable.WriteBulk(&bulkMutsMetadataUpdate, bigtable.tableMetadataUpdates, DEFAULT_BATCH_INSERTS)
+		if err != nil {
+			return fmt.Errorf("error writing blocks [%v-%v] to bigtable metadata updates table: %w", blocks[0].Number, blocks[len(blocks)-1].Number, err)
+		}
+	}*/
+
+	return nil
+}
diff --git a/backend/pkg/commons/indexer/indexer_test.go b/backend/pkg/commons/indexer/indexer_test.go
new file mode 100644
index 000000000..b72e3b068
--- /dev/null
+++ b/backend/pkg/commons/indexer/indexer_test.go
@@ -0,0 +1,71 @@
+package indexer
+
+import (
+	"context"
+	"fmt"
+	"math/big"
+	"testing"
+
+	"github.com/gobitfly/beaconchain/internal/th"
+	"github.com/gobitfly/beaconchain/pkg/commons/db2/data"
+	"github.com/gobitfly/beaconchain/pkg/commons/db2/database"
+	"github.com/gobitfly/beaconchain/pkg/commons/db2/databasetest"
+	"github.com/gobitfly/beaconchain/pkg/commons/rpc"
+	"github.com/gobitfly/beaconchain/pkg/commons/types"
+)
+
+func TestIndexer(t *testing.T) {
+	btClient, btAdmin := databasetest.NewBigTable(t)
+
+	bigtable, err := database.NewBigTableWithClient(context.Background(), btClient, btAdmin, data.Schema)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	transform := NewTransformer(NoopCache{})
+
+	indexer := New(data.NewStore(database.Wrap(bigtable, data.Table)), transform.Tx, transform.ERC20)
+
+	backend := th.NewBackend(t)
+	client, err := rpc.NewErigonClient(backend.Endpoint)
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, usdt := backend.DeployToken(t, "usdt", "usdt", backend.BankAccount.From)
+
+	for i := 0; i < 10; i++ {
+		temp := th.CreateEOA(t)
+		if err := backend.Client().SendTransaction(context.Background(), backend.MakeTx(t, backend.BankAccount, &temp.From, big.NewInt(1), nil)); err != nil {
+			t.Fatal(err)
+		}
+		if _, err := usdt.Mint(backend.BankAccount.TransactOpts, temp.From, big.NewInt(1)); err != nil {
+			t.Fatal(err)
+		}
+		backend.Commit()
+
+		lastBlock, err := backend.Client().BlockNumber(context.Background())
+		if err != nil {
+			t.Fatal(err)
+		}
+		block, _, err := client.GetBlock(int64(lastBlock), "geth")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if err := indexer.IndexBlocksWithTransformers(fmt.Sprintf("%d", backend.ChainID), []*types.Eth1Block{block}); err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	rows, err := bigtable.Read(data.Table, "")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if len(rows) == 0 {
+		t.Errorf("no rows found")
+	}
+
+	for _, row := range rows {
+		t.Log(row.Key)
+	}
+}
diff --git a/backend/pkg/commons/indexer/tranformer.go b/backend/pkg/commons/indexer/tranformer.go
new file mode 100644
index 000000000..c4893d6b5
--- /dev/null
+++ b/backend/pkg/commons/indexer/tranformer.go
@@ -0,0 +1,163 @@
+package indexer
+
+import (
+	"bytes"
+	"maps"
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/pkg/errors"
+
+	gethtypes "github.com/ethereum/go-ethereum/core/types"
+
+	"github.com/gobitfly/beaconchain/pkg/commons/db2/data"
+	"github.com/gobitfly/beaconchain/pkg/commons/db2/database"
+	"github.com/gobitfly/beaconchain/pkg/commons/db2/metadata"
+	"github.com/gobitfly/beaconchain/pkg/commons/erc20"
+	"github.com/gobitfly/beaconchain/pkg/commons/types"
+)
+
+type Transformer struct {
+	cache metadata.Cache
+}
+
+func NewTransformer(cache metadata.Cache) *Transformer {
+	return &Transformer{
+		cache: cache,
+	}
+}
+
+func (t *Transformer) Tx(chainID string, blk *types.Eth1Block) (map[string][]database.Item, map[string][]database.Item, error) {
+	/*	startTime := time.Now()
+		defer func() {
+			metrics.TaskDuration.WithLabelValues("bt_transform_tx").Observe(time.Since(startTime).Seconds())
+		}()*/
+
+	updateMetadata := make(map[string][]database.Item)
+	var transactions []*types.Eth1TransactionIndexed
+	for _, tx := range blk.Transactions {
+		to := tx.GetTo()
+		isContract := false
+		if !bytes.Equal(tx.GetContractAddress(), common.Address{}.Bytes()) {
+			to = tx.GetContractAddress()
+			isContract = true
+		}
+		method := make([]byte, 0)
+		if len(tx.GetData()) > 3 {
+			method = tx.GetData()[:4]
+		}
+
+		fee := new(big.Int).Mul(new(big.Int).SetBytes(tx.GetGasPrice()), big.NewInt(int64(tx.GetGasUsed()))).Bytes()
+		blobFee := new(big.Int).Mul(new(big.Int).SetBytes(tx.GetBlobGasPrice()), big.NewInt(int64(tx.GetBlobGasUsed()))).Bytes()
+		indexedTx := &types.Eth1TransactionIndexed{
+			Hash:               tx.GetHash(),
+			BlockNumber:        blk.GetNumber(),
+			Time:               blk.GetTime(),
+			MethodId:           method,
+			From:               tx.GetFrom(),
+			To:                 to,
+			Value:              tx.GetValue(),
+			TxFee:              fee,
+			GasPrice:           tx.GetGasPrice(),
+			IsContractCreation: isContract,
+			ErrorMsg:           "",
+			BlobTxFee:          blobFee,
+			BlobGasPrice:       tx.GetBlobGasPrice(),
+			Status:             types.StatusType(tx.Status),
+		}
+		for _, itx := range tx.Itx {
+			if itx.ErrorMsg != "" {
+				indexedTx.ErrorMsg = itx.ErrorMsg
+				if indexedTx.Status == types.StatusType_SUCCESS {
+					indexedTx.Status = types.StatusType_PARTIAL
+				}
+				break
+			}
+		}
+
+		transactions = append(transactions, indexedTx)
+
+		// mark sender and recipient for balance update
+		maps.Copy(updateMetadata, metadata.MarkBalanceUpdate(chainID, indexedTx.From, []byte{0x0}, t.cache))
+		maps.Copy(updateMetadata, metadata.MarkBalanceUpdate(chainID, indexedTx.To, []byte{0x0}, t.cache))
+	}
+	update, err := data.BlockTransactionsToItemsV2(chainID, transactions)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	return update, updateMetadata, nil
+}
+
+func (t *Transformer) ERC20(chainID string, blk *types.Eth1Block) (map[string][]database.Item, map[string][]database.Item, error) {
+	/*	startTime := time.Now()
+		defer func() {
+			metrics.TaskDuration.WithLabelValues("bt_transform_erc20").Observe(time.Since(startTime).Seconds())
+		}()*/
+
+	updateMetadata := make(map[string][]database.Item)
+	filterer, err := erc20.NewErc20Filterer(common.Address{}, nil)
+	if err != nil {
+		return nil, nil, errors.Wrap(err, "cannot ERC20 create filterer")
+	}
+	var transfers []data.TransferWithIndexes
+	for txIndex, tx := range blk.GetTransactions() {
+		for logIndex, log := range tx.GetLogs() {
+			if len(log.GetTopics()) != 3 || !bytes.Equal(log.GetTopics()[0], erc20.TransferTopic) {
+				continue
+			}
+
+			topics := make([]common.Hash, 0, len(log.GetTopics()))
+
+			for _, lTopic := range log.GetTopics() {
+				topics = append(topics, common.BytesToHash(lTopic))
+			}
+
+			ethLog := gethtypes.Log{
+				Address:     common.BytesToAddress(log.GetAddress()),
+				Data:        log.Data,
+				Topics:      topics,
+				BlockNumber: blk.GetNumber(),
+				TxHash:      common.BytesToHash(tx.GetHash()),
+				TxIndex:     uint(txIndex),
+				BlockHash:   common.BytesToHash(blk.GetHash()),
+				Index:       uint(logIndex),
+				Removed:     log.GetRemoved(),
+			}
+
+			transfer, _ := filterer.ParseTransfer(ethLog)
+			if transfer == nil {
+				continue
+			}
+
+			var value []byte
+			if transfer.Value != nil {
+				value = transfer.Value.Bytes()
+			}
+
+			indexedLog := &types.Eth1ERC20Indexed{
+				ParentHash:   tx.GetHash(),
+				BlockNumber:  blk.GetNumber(),
+				Time:         blk.GetTime(),
+				TokenAddress: log.Address,
+				From:         transfer.From.Bytes(),
+				To:           transfer.To.Bytes(),
+				Value:        value,
+			}
+			transfers = append(transfers, data.TransferWithIndexes{
+				Indexed:  indexedLog,
+				TxIndex:  txIndex,
+				LogIndex: logIndex,
+			})
+
+			// mark sender and recipient for balance update
+			maps.Copy(updateMetadata, metadata.MarkBalanceUpdate(chainID, indexedLog.From, indexedLog.TokenAddress, t.cache))
+			maps.Copy(updateMetadata, metadata.MarkBalanceUpdate(chainID, indexedLog.To, indexedLog.TokenAddress, t.cache))
+		}
+	}
+	update, err := data.BlockERC20TransfersToItemsV2(chainID, transfers)
+	if err != nil {
+		return nil, nil, err
+	}
+	return update, updateMetadata, nil
+}
diff --git a/backend/pkg/commons/rpc/erigon.go b/backend/pkg/commons/rpc/erigon.go
index eeacf95e6..7313d0d21 100644
--- a/backend/pkg/commons/rpc/erigon.go
+++ b/backend/pkg/commons/rpc/erigon.go
@@ -3,17 +3,16 @@ package rpc
 import (
 	"context"
 	"encoding/hex"
+	"fmt"
+	"math/big"
+	"strings"
+	"time"
 
 	"github.com/gobitfly/beaconchain/pkg/commons/contracts/oneinchoracle"
 	"github.com/gobitfly/beaconchain/pkg/commons/log"
 
 	"github.com/gobitfly/beaconchain/pkg/commons/erc20"
 
-	"fmt"
-	"math/big"
-	"strings"
-	"time"
-
 	"github.com/davecgh/go-spew/spew"
 	"github.com/ethereum/go-ethereum"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
@@ -21,10 +20,11 @@ import (
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/ethclient"
 	gethrpc "github.com/ethereum/go-ethereum/rpc"
-	"github.com/gobitfly/beaconchain/pkg/commons/types"
 	"golang.org/x/sync/errgroup"
 	"google.golang.org/protobuf/types/known/timestamppb"
 
+	"github.com/gobitfly/beaconchain/pkg/commons/types"
+
 	gethtypes "github.com/ethereum/go-ethereum/core/types"
 )
 
diff --git a/backend/pkg/commons/types/eth1.pb.go b/backend/pkg/commons/types/eth1.pb.go
index 8275684c1..803743344 100644
--- a/backend/pkg/commons/types/eth1.pb.go
+++ b/backend/pkg/commons/types/eth1.pb.go
@@ -1,15 +1,15 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
 // 	protoc-gen-go v1.27.1
-// 	protoc        v3.12.4
+// 	protoc        v5.28.2
 // source: eth1.proto
 
 package types
 
 import (
-	timestamp "github.com/golang/protobuf/ptypes/timestamp"
 	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
 	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
 	reflect "reflect"
 	sync "sync"
 )
@@ -21,31 +21,80 @@ const (
 	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
 )
 
+type StatusType int32
+
+const (
+	StatusType_FAILED  StatusType = 0
+	StatusType_SUCCESS StatusType = 1
+	StatusType_PARTIAL StatusType = 2
+)
+
+// Enum value maps for StatusType.
+var (
+	StatusType_name = map[int32]string{
+		0: "FAILED",
+		1: "SUCCESS",
+		2: "PARTIAL",
+	}
+	StatusType_value = map[string]int32{
+		"FAILED":  0,
+		"SUCCESS": 1,
+		"PARTIAL": 2,
+	}
+)
+
+func (x StatusType) Enum() *StatusType {
+	p := new(StatusType)
+	*p = x
+	return p
+}
+
+func (x StatusType) String() string {
+	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (StatusType) Descriptor() protoreflect.EnumDescriptor {
+	return file_eth1_proto_enumTypes[0].Descriptor()
+}
+
+func (StatusType) Type() protoreflect.EnumType {
+	return &file_eth1_proto_enumTypes[0]
+}
+
+func (x StatusType) Number() protoreflect.EnumNumber {
+	return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Use StatusType.Descriptor instead.
+func (StatusType) EnumDescriptor() ([]byte, []int) {
+	return file_eth1_proto_rawDescGZIP(), []int{0}
+}
+
 // Eth1Block is stored in the blocks table under <chainID>:<reversePaddedNumber>
 type Eth1Block struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Hash         []byte               `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
-	ParentHash   []byte               `protobuf:"bytes,2,opt,name=parent_hash,json=parentHash,proto3" json:"parent_hash,omitempty"`
-	UncleHash    []byte               `protobuf:"bytes,3,opt,name=uncle_hash,json=uncleHash,proto3" json:"uncle_hash,omitempty"`
-	Coinbase     []byte               `protobuf:"bytes,4,opt,name=coinbase,proto3" json:"coinbase,omitempty"`
-	Root         []byte               `protobuf:"bytes,5,opt,name=root,proto3" json:"root,omitempty"`
-	TxHash       []byte               `protobuf:"bytes,6,opt,name=tx_hash,json=txHash,proto3" json:"tx_hash,omitempty"`
-	ReceiptHash  []byte               `protobuf:"bytes,7,opt,name=receipt_hash,json=receiptHash,proto3" json:"receipt_hash,omitempty"`
-	Difficulty   []byte               `protobuf:"bytes,8,opt,name=difficulty,proto3" json:"difficulty,omitempty"`
-	Number       uint64               `protobuf:"varint,9,opt,name=number,proto3" json:"number,omitempty"`
-	GasLimit     uint64               `protobuf:"varint,10,opt,name=gas_limit,json=gasLimit,proto3" json:"gas_limit,omitempty"`
-	GasUsed      uint64               `protobuf:"varint,11,opt,name=gas_used,json=gasUsed,proto3" json:"gas_used,omitempty"`
-	Time         *timestamp.Timestamp `protobuf:"bytes,12,opt,name=time,proto3" json:"time,omitempty"`
-	Extra        []byte               `protobuf:"bytes,13,opt,name=extra,proto3" json:"extra,omitempty"`
-	MixDigest    []byte               `protobuf:"bytes,14,opt,name=mix_digest,json=mixDigest,proto3" json:"mix_digest,omitempty"`
-	Bloom        []byte               `protobuf:"bytes,17,opt,name=bloom,proto3" json:"bloom,omitempty"`
-	BaseFee      []byte               `protobuf:"bytes,18,opt,name=base_fee,json=baseFee,proto3" json:"base_fee,omitempty"`
-	Uncles       []*Eth1Block         `protobuf:"bytes,20,rep,name=uncles,proto3" json:"uncles,omitempty"`
-	Transactions []*Eth1Transaction   `protobuf:"bytes,21,rep,name=transactions,proto3" json:"transactions,omitempty"`
-	Withdrawals  []*Eth1Withdrawal    `protobuf:"bytes,22,rep,name=withdrawals,proto3" json:"withdrawals,omitempty"`
+	Hash         []byte                 `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
+	ParentHash   []byte                 `protobuf:"bytes,2,opt,name=parent_hash,json=parentHash,proto3" json:"parent_hash,omitempty"`
+	UncleHash    []byte                 `protobuf:"bytes,3,opt,name=uncle_hash,json=uncleHash,proto3" json:"uncle_hash,omitempty"`
+	Coinbase     []byte                 `protobuf:"bytes,4,opt,name=coinbase,proto3" json:"coinbase,omitempty"`
+	Root         []byte                 `protobuf:"bytes,5,opt,name=root,proto3" json:"root,omitempty"`
+	TxHash       []byte                 `protobuf:"bytes,6,opt,name=tx_hash,json=txHash,proto3" json:"tx_hash,omitempty"`
+	ReceiptHash  []byte                 `protobuf:"bytes,7,opt,name=receipt_hash,json=receiptHash,proto3" json:"receipt_hash,omitempty"`
+	Difficulty   []byte                 `protobuf:"bytes,8,opt,name=difficulty,proto3" json:"difficulty,omitempty"`
+	Number       uint64                 `protobuf:"varint,9,opt,name=number,proto3" json:"number,omitempty"`
+	GasLimit     uint64                 `protobuf:"varint,10,opt,name=gas_limit,json=gasLimit,proto3" json:"gas_limit,omitempty"`
+	GasUsed      uint64                 `protobuf:"varint,11,opt,name=gas_used,json=gasUsed,proto3" json:"gas_used,omitempty"`
+	Time         *timestamppb.Timestamp `protobuf:"bytes,12,opt,name=time,proto3" json:"time,omitempty"`
+	Extra        []byte                 `protobuf:"bytes,13,opt,name=extra,proto3" json:"extra,omitempty"`
+	MixDigest    []byte                 `protobuf:"bytes,14,opt,name=mix_digest,json=mixDigest,proto3" json:"mix_digest,omitempty"`
+	Bloom        []byte                 `protobuf:"bytes,17,opt,name=bloom,proto3" json:"bloom,omitempty"`
+	BaseFee      []byte                 `protobuf:"bytes,18,opt,name=base_fee,json=baseFee,proto3" json:"base_fee,omitempty"`
+	Uncles       []*Eth1Block           `protobuf:"bytes,20,rep,name=uncles,proto3" json:"uncles,omitempty"`
+	Transactions []*Eth1Transaction     `protobuf:"bytes,21,rep,name=transactions,proto3" json:"transactions,omitempty"`
+	Withdrawals  []*Eth1Withdrawal      `protobuf:"bytes,22,rep,name=withdrawals,proto3" json:"withdrawals,omitempty"`
 	// EIP 4844
 	BlobGasUsed   uint64 `protobuf:"varint,23,opt,name=blob_gas_used,json=blobGasUsed,proto3" json:"blob_gas_used,omitempty"`
 	ExcessBlobGas uint64 `protobuf:"varint,24,opt,name=excess_blob_gas,json=excessBlobGas,proto3" json:"excess_blob_gas,omitempty"`
@@ -160,7 +209,7 @@ func (x *Eth1Block) GetGasUsed() uint64 {
 	return 0
 }
 
-func (x *Eth1Block) GetTime() *timestamp.Timestamp {
+func (x *Eth1Block) GetTime() *timestamppb.Timestamp {
 	if x != nil {
 		return x.Time
 	}
@@ -320,13 +369,14 @@ type Eth1Transaction struct {
 	AccessList           []*AccessList `protobuf:"bytes,15,rep,name=access_list,json=accessList,proto3" json:"access_list,omitempty"`
 	Hash                 []byte        `protobuf:"bytes,16,opt,name=hash,proto3" json:"hash,omitempty"`
 	// Receipt fields
-	ContractAddress    []byte     `protobuf:"bytes,17,opt,name=contract_address,json=contractAddress,proto3" json:"contract_address,omitempty"`
-	CommulativeGasUsed uint64     `protobuf:"varint,18,opt,name=commulative_gas_used,json=commulativeGasUsed,proto3" json:"commulative_gas_used,omitempty"`
-	GasUsed            uint64     `protobuf:"varint,19,opt,name=gas_used,json=gasUsed,proto3" json:"gas_used,omitempty"`
-	LogsBloom          []byte     `protobuf:"bytes,20,opt,name=logs_bloom,json=logsBloom,proto3" json:"logs_bloom,omitempty"`
-	Status             uint64     `protobuf:"varint,21,opt,name=status,proto3" json:"status,omitempty"`
-	ErrorMsg           string     `protobuf:"bytes,22,opt,name=error_msg,json=errorMsg,proto3" json:"error_msg,omitempty"`
-	Logs               []*Eth1Log `protobuf:"bytes,23,rep,name=logs,proto3" json:"logs,omitempty"`
+	ContractAddress    []byte `protobuf:"bytes,17,opt,name=contract_address,json=contractAddress,proto3" json:"contract_address,omitempty"`
+	CommulativeGasUsed uint64 `protobuf:"varint,18,opt,name=commulative_gas_used,json=commulativeGasUsed,proto3" json:"commulative_gas_used,omitempty"`
+	GasUsed            uint64 `protobuf:"varint,19,opt,name=gas_used,json=gasUsed,proto3" json:"gas_used,omitempty"`
+	LogsBloom          []byte `protobuf:"bytes,20,opt,name=logs_bloom,json=logsBloom,proto3" json:"logs_bloom,omitempty"`
+	Status             uint64 `protobuf:"varint,21,opt,name=status,proto3" json:"status,omitempty"`
+	// reserved 22; // string error_msg = 22;
+	ErrorMsg string     `protobuf:"bytes,22,opt,name=error_msg,json=errorMsg,proto3" json:"error_msg,omitempty"`
+	Logs     []*Eth1Log `protobuf:"bytes,23,rep,name=logs,proto3" json:"logs,omitempty"`
 	// Internal transactions
 	Itx []*Eth1InternalTransaction `protobuf:"bytes,24,rep,name=itx,proto3" json:"itx,omitempty"`
 	// EIP 4844 transaction
@@ -817,21 +867,21 @@ type Eth1BlockIndexed struct {
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Hash             []byte               `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
-	ParentHash       []byte               `protobuf:"bytes,2,opt,name=parent_hash,json=parentHash,proto3" json:"parent_hash,omitempty"`
-	UncleHash        []byte               `protobuf:"bytes,3,opt,name=uncle_hash,json=uncleHash,proto3" json:"uncle_hash,omitempty"`
-	Coinbase         []byte               `protobuf:"bytes,4,opt,name=coinbase,proto3" json:"coinbase,omitempty"`
-	Difficulty       []byte               `protobuf:"bytes,8,opt,name=difficulty,proto3" json:"difficulty,omitempty"`
-	Number           uint64               `protobuf:"varint,9,opt,name=number,proto3" json:"number,omitempty"`
-	GasLimit         uint64               `protobuf:"varint,10,opt,name=gas_limit,json=gasLimit,proto3" json:"gas_limit,omitempty"`
-	GasUsed          uint64               `protobuf:"varint,11,opt,name=gas_used,json=gasUsed,proto3" json:"gas_used,omitempty"`
-	Time             *timestamp.Timestamp `protobuf:"bytes,12,opt,name=time,proto3" json:"time,omitempty"`
-	BaseFee          []byte               `protobuf:"bytes,18,opt,name=base_fee,json=baseFee,proto3" json:"base_fee,omitempty"`
-	UncleCount       uint64               `protobuf:"varint,19,opt,name=uncle_count,json=uncleCount,proto3" json:"uncle_count,omitempty"`
-	TransactionCount uint64               `protobuf:"varint,20,opt,name=transaction_count,json=transactionCount,proto3" json:"transaction_count,omitempty"`
-	Mev              []byte               `protobuf:"bytes,21,opt,name=mev,proto3" json:"mev,omitempty"`
-	LowestGasPrice   []byte               `protobuf:"bytes,22,opt,name=lowest_gas_price,json=lowestGasPrice,proto3" json:"lowest_gas_price,omitempty"`
-	HighestGasPrice  []byte               `protobuf:"bytes,23,opt,name=highest_gas_price,json=highestGasPrice,proto3" json:"highest_gas_price,omitempty"`
+	Hash             []byte                 `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
+	ParentHash       []byte                 `protobuf:"bytes,2,opt,name=parent_hash,json=parentHash,proto3" json:"parent_hash,omitempty"`
+	UncleHash        []byte                 `protobuf:"bytes,3,opt,name=uncle_hash,json=uncleHash,proto3" json:"uncle_hash,omitempty"`
+	Coinbase         []byte                 `protobuf:"bytes,4,opt,name=coinbase,proto3" json:"coinbase,omitempty"`
+	Difficulty       []byte                 `protobuf:"bytes,8,opt,name=difficulty,proto3" json:"difficulty,omitempty"`
+	Number           uint64                 `protobuf:"varint,9,opt,name=number,proto3" json:"number,omitempty"`
+	GasLimit         uint64                 `protobuf:"varint,10,opt,name=gas_limit,json=gasLimit,proto3" json:"gas_limit,omitempty"`
+	GasUsed          uint64                 `protobuf:"varint,11,opt,name=gas_used,json=gasUsed,proto3" json:"gas_used,omitempty"`
+	Time             *timestamppb.Timestamp `protobuf:"bytes,12,opt,name=time,proto3" json:"time,omitempty"`
+	BaseFee          []byte                 `protobuf:"bytes,18,opt,name=base_fee,json=baseFee,proto3" json:"base_fee,omitempty"`
+	UncleCount       uint64                 `protobuf:"varint,19,opt,name=uncle_count,json=uncleCount,proto3" json:"uncle_count,omitempty"`
+	TransactionCount uint64                 `protobuf:"varint,20,opt,name=transaction_count,json=transactionCount,proto3" json:"transaction_count,omitempty"`
+	Mev              []byte                 `protobuf:"bytes,21,opt,name=mev,proto3" json:"mev,omitempty"`
+	LowestGasPrice   []byte                 `protobuf:"bytes,22,opt,name=lowest_gas_price,json=lowestGasPrice,proto3" json:"lowest_gas_price,omitempty"`
+	HighestGasPrice  []byte                 `protobuf:"bytes,23,opt,name=highest_gas_price,json=highestGasPrice,proto3" json:"highest_gas_price,omitempty"`
 	// uint64 duration = 24;
 	TxReward    []byte `protobuf:"bytes,25,opt,name=tx_reward,json=txReward,proto3" json:"tx_reward,omitempty"`
 	UncleReward []byte `protobuf:"bytes,26,opt,name=uncle_reward,json=uncleReward,proto3" json:"uncle_reward,omitempty"`
@@ -932,7 +982,7 @@ func (x *Eth1BlockIndexed) GetGasUsed() uint64 {
 	return 0
 }
 
-func (x *Eth1BlockIndexed) GetTime() *timestamp.Timestamp {
+func (x *Eth1BlockIndexed) GetTime() *timestamppb.Timestamp {
 	if x != nil {
 		return x.Time
 	}
@@ -1028,14 +1078,14 @@ type Eth1UncleIndexed struct {
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	BlockNumber uint64               `protobuf:"varint,1,opt,name=block_number,json=blockNumber,proto3" json:"block_number,omitempty"`
-	Number      uint64               `protobuf:"varint,2,opt,name=number,proto3" json:"number,omitempty"`
-	GasLimit    uint64               `protobuf:"varint,3,opt,name=gas_limit,json=gasLimit,proto3" json:"gas_limit,omitempty"`
-	GasUsed     uint64               `protobuf:"varint,4,opt,name=gas_used,json=gasUsed,proto3" json:"gas_used,omitempty"`
-	BaseFee     []byte               `protobuf:"bytes,5,opt,name=base_fee,json=baseFee,proto3" json:"base_fee,omitempty"`
-	Difficulty  []byte               `protobuf:"bytes,6,opt,name=difficulty,proto3" json:"difficulty,omitempty"`
-	Time        *timestamp.Timestamp `protobuf:"bytes,7,opt,name=time,proto3" json:"time,omitempty"`
-	Reward      []byte               `protobuf:"bytes,8,opt,name=reward,proto3" json:"reward,omitempty"`
+	BlockNumber uint64                 `protobuf:"varint,1,opt,name=block_number,json=blockNumber,proto3" json:"block_number,omitempty"`
+	Number      uint64                 `protobuf:"varint,2,opt,name=number,proto3" json:"number,omitempty"`
+	GasLimit    uint64                 `protobuf:"varint,3,opt,name=gas_limit,json=gasLimit,proto3" json:"gas_limit,omitempty"`
+	GasUsed     uint64                 `protobuf:"varint,4,opt,name=gas_used,json=gasUsed,proto3" json:"gas_used,omitempty"`
+	BaseFee     []byte                 `protobuf:"bytes,5,opt,name=base_fee,json=baseFee,proto3" json:"base_fee,omitempty"`
+	Difficulty  []byte                 `protobuf:"bytes,6,opt,name=difficulty,proto3" json:"difficulty,omitempty"`
+	Time        *timestamppb.Timestamp `protobuf:"bytes,7,opt,name=time,proto3" json:"time,omitempty"`
+	Reward      []byte                 `protobuf:"bytes,8,opt,name=reward,proto3" json:"reward,omitempty"`
 }
 
 func (x *Eth1UncleIndexed) Reset() {
@@ -1112,7 +1162,7 @@ func (x *Eth1UncleIndexed) GetDifficulty() []byte {
 	return nil
 }
 
-func (x *Eth1UncleIndexed) GetTime() *timestamp.Timestamp {
+func (x *Eth1UncleIndexed) GetTime() *timestamppb.Timestamp {
 	if x != nil {
 		return x.Time
 	}
@@ -1131,12 +1181,12 @@ type Eth1WithdrawalIndexed struct {
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	BlockNumber    uint64               `protobuf:"varint,1,opt,name=block_number,json=blockNumber,proto3" json:"block_number,omitempty"`
-	Index          uint64               `protobuf:"varint,2,opt,name=index,proto3" json:"index,omitempty"`
-	ValidatorIndex uint64               `protobuf:"varint,3,opt,name=validator_index,json=validatorIndex,proto3" json:"validator_index,omitempty"`
-	Address        []byte               `protobuf:"bytes,4,opt,name=address,proto3" json:"address,omitempty"`
-	Amount         []byte               `protobuf:"bytes,5,opt,name=amount,proto3" json:"amount,omitempty"`
-	Time           *timestamp.Timestamp `protobuf:"bytes,6,opt,name=time,proto3" json:"time,omitempty"`
+	BlockNumber    uint64                 `protobuf:"varint,1,opt,name=block_number,json=blockNumber,proto3" json:"block_number,omitempty"`
+	Index          uint64                 `protobuf:"varint,2,opt,name=index,proto3" json:"index,omitempty"`
+	ValidatorIndex uint64                 `protobuf:"varint,3,opt,name=validator_index,json=validatorIndex,proto3" json:"validator_index,omitempty"`
+	Address        []byte                 `protobuf:"bytes,4,opt,name=address,proto3" json:"address,omitempty"`
+	Amount         []byte                 `protobuf:"bytes,5,opt,name=amount,proto3" json:"amount,omitempty"`
+	Time           *timestamppb.Timestamp `protobuf:"bytes,6,opt,name=time,proto3" json:"time,omitempty"`
 }
 
 func (x *Eth1WithdrawalIndexed) Reset() {
@@ -1206,7 +1256,7 @@ func (x *Eth1WithdrawalIndexed) GetAmount() []byte {
 	return nil
 }
 
-func (x *Eth1WithdrawalIndexed) GetTime() *timestamp.Timestamp {
+func (x *Eth1WithdrawalIndexed) GetTime() *timestamppb.Timestamp {
 	if x != nil {
 		return x.Time
 	}
@@ -1218,22 +1268,23 @@ type Eth1TransactionIndexed struct {
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Hash               []byte               `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
-	BlockNumber        uint64               `protobuf:"varint,2,opt,name=block_number,json=blockNumber,proto3" json:"block_number,omitempty"`
-	Time               *timestamp.Timestamp `protobuf:"bytes,3,opt,name=time,proto3" json:"time,omitempty"`
-	MethodId           []byte               `protobuf:"bytes,4,opt,name=method_id,json=methodId,proto3" json:"method_id,omitempty"`
-	From               []byte               `protobuf:"bytes,5,opt,name=from,proto3" json:"from,omitempty"`
-	To                 []byte               `protobuf:"bytes,6,opt,name=to,proto3" json:"to,omitempty"`
-	Value              []byte               `protobuf:"bytes,7,opt,name=value,proto3" json:"value,omitempty"`
-	TxFee              []byte               `protobuf:"bytes,8,opt,name=tx_fee,json=txFee,proto3" json:"tx_fee,omitempty"`
-	GasPrice           []byte               `protobuf:"bytes,9,opt,name=gas_price,json=gasPrice,proto3" json:"gas_price,omitempty"`
-	IsContractCreation bool                 `protobuf:"varint,10,opt,name=is_contract_creation,json=isContractCreation,proto3" json:"is_contract_creation,omitempty"`
-	// invokes_contract is unused, should mark reserved!
+	Hash               []byte                 `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
+	BlockNumber        uint64                 `protobuf:"varint,2,opt,name=block_number,json=blockNumber,proto3" json:"block_number,omitempty"`
+	Time               *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=time,proto3" json:"time,omitempty"`
+	MethodId           []byte                 `protobuf:"bytes,4,opt,name=method_id,json=methodId,proto3" json:"method_id,omitempty"`
+	From               []byte                 `protobuf:"bytes,5,opt,name=from,proto3" json:"from,omitempty"`
+	To                 []byte                 `protobuf:"bytes,6,opt,name=to,proto3" json:"to,omitempty"`
+	Value              []byte                 `protobuf:"bytes,7,opt,name=value,proto3" json:"value,omitempty"`
+	TxFee              []byte                 `protobuf:"bytes,8,opt,name=tx_fee,json=txFee,proto3" json:"tx_fee,omitempty"`
+	GasPrice           []byte                 `protobuf:"bytes,9,opt,name=gas_price,json=gasPrice,proto3" json:"gas_price,omitempty"`
+	IsContractCreation bool                   `protobuf:"varint,10,opt,name=is_contract_creation,json=isContractCreation,proto3" json:"is_contract_creation,omitempty"`
+	// reserved 11; // bool invokes_contract = 11;
 	InvokesContract bool   `protobuf:"varint,11,opt,name=invokes_contract,json=invokesContract,proto3" json:"invokes_contract,omitempty"`
 	ErrorMsg        string `protobuf:"bytes,12,opt,name=error_msg,json=errorMsg,proto3" json:"error_msg,omitempty"`
 	// EIP 4844
-	BlobTxFee    []byte `protobuf:"bytes,13,opt,name=blob_tx_fee,json=blobTxFee,proto3" json:"blob_tx_fee,omitempty"`
-	BlobGasPrice []byte `protobuf:"bytes,14,opt,name=blob_gas_price,json=blobGasPrice,proto3" json:"blob_gas_price,omitempty"`
+	BlobTxFee    []byte     `protobuf:"bytes,13,opt,name=blob_tx_fee,json=blobTxFee,proto3" json:"blob_tx_fee,omitempty"`
+	BlobGasPrice []byte     `protobuf:"bytes,14,opt,name=blob_gas_price,json=blobGasPrice,proto3" json:"blob_gas_price,omitempty"`
+	Status       StatusType `protobuf:"varint,15,opt,name=status,proto3,enum=types.StatusType" json:"status,omitempty"`
 }
 
 func (x *Eth1TransactionIndexed) Reset() {
@@ -1282,7 +1333,7 @@ func (x *Eth1TransactionIndexed) GetBlockNumber() uint64 {
 	return 0
 }
 
-func (x *Eth1TransactionIndexed) GetTime() *timestamp.Timestamp {
+func (x *Eth1TransactionIndexed) GetTime() *timestamppb.Timestamp {
 	if x != nil {
 		return x.Time
 	}
@@ -1366,18 +1417,26 @@ func (x *Eth1TransactionIndexed) GetBlobGasPrice() []byte {
 	return nil
 }
 
+func (x *Eth1TransactionIndexed) GetStatus() StatusType {
+	if x != nil {
+		return x.Status
+	}
+	return StatusType_FAILED
+}
+
 type Eth1InternalTransactionIndexed struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	ParentHash  []byte               `protobuf:"bytes,1,opt,name=parent_hash,json=parentHash,proto3" json:"parent_hash,omitempty"`
-	BlockNumber uint64               `protobuf:"varint,2,opt,name=block_number,json=blockNumber,proto3" json:"block_number,omitempty"`
-	Type        string               `protobuf:"bytes,3,opt,name=type,proto3" json:"type,omitempty"`
-	Time        *timestamp.Timestamp `protobuf:"bytes,4,opt,name=time,proto3" json:"time,omitempty"`
-	From        []byte               `protobuf:"bytes,5,opt,name=from,proto3" json:"from,omitempty"`
-	To          []byte               `protobuf:"bytes,6,opt,name=to,proto3" json:"to,omitempty"`
-	Value       []byte               `protobuf:"bytes,7,opt,name=value,proto3" json:"value,omitempty"`
+	ParentHash  []byte                 `protobuf:"bytes,1,opt,name=parent_hash,json=parentHash,proto3" json:"parent_hash,omitempty"`
+	BlockNumber uint64                 `protobuf:"varint,2,opt,name=block_number,json=blockNumber,proto3" json:"block_number,omitempty"`
+	Type        string                 `protobuf:"bytes,3,opt,name=type,proto3" json:"type,omitempty"`
+	Time        *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=time,proto3" json:"time,omitempty"`
+	From        []byte                 `protobuf:"bytes,5,opt,name=from,proto3" json:"from,omitempty"`
+	To          []byte                 `protobuf:"bytes,6,opt,name=to,proto3" json:"to,omitempty"`
+	Value       []byte                 `protobuf:"bytes,7,opt,name=value,proto3" json:"value,omitempty"`
+	Reverted    bool                   `protobuf:"varint,8,opt,name=reverted,proto3" json:"reverted,omitempty"`
 }
 
 func (x *Eth1InternalTransactionIndexed) Reset() {
@@ -1433,7 +1492,7 @@ func (x *Eth1InternalTransactionIndexed) GetType() string {
 	return ""
 }
 
-func (x *Eth1InternalTransactionIndexed) GetTime() *timestamp.Timestamp {
+func (x *Eth1InternalTransactionIndexed) GetTime() *timestamppb.Timestamp {
 	if x != nil {
 		return x.Time
 	}
@@ -1461,24 +1520,32 @@ func (x *Eth1InternalTransactionIndexed) GetValue() []byte {
 	return nil
 }
 
+func (x *Eth1InternalTransactionIndexed) GetReverted() bool {
+	if x != nil {
+		return x.Reverted
+	}
+	return false
+}
+
 // https://eips.ethereum.org/EIPS/eip-4844
 type Eth1BlobTransactionIndexed struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	Hash                []byte               `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
-	BlockNumber         uint64               `protobuf:"varint,2,opt,name=block_number,json=blockNumber,proto3" json:"block_number,omitempty"`
-	Time                *timestamp.Timestamp `protobuf:"bytes,3,opt,name=time,proto3" json:"time,omitempty"`
-	From                []byte               `protobuf:"bytes,4,opt,name=from,proto3" json:"from,omitempty"`
-	To                  []byte               `protobuf:"bytes,5,opt,name=to,proto3" json:"to,omitempty"`
-	Value               []byte               `protobuf:"bytes,6,opt,name=value,proto3" json:"value,omitempty"`
-	TxFee               []byte               `protobuf:"bytes,7,opt,name=tx_fee,json=txFee,proto3" json:"tx_fee,omitempty"`
-	GasPrice            []byte               `protobuf:"bytes,8,opt,name=gas_price,json=gasPrice,proto3" json:"gas_price,omitempty"`
-	BlobTxFee           []byte               `protobuf:"bytes,9,opt,name=blob_tx_fee,json=blobTxFee,proto3" json:"blob_tx_fee,omitempty"`
-	BlobGasPrice        []byte               `protobuf:"bytes,10,opt,name=blob_gas_price,json=blobGasPrice,proto3" json:"blob_gas_price,omitempty"`
-	ErrorMsg            string               `protobuf:"bytes,12,opt,name=error_msg,json=errorMsg,proto3" json:"error_msg,omitempty"`
-	BlobVersionedHashes [][]byte             `protobuf:"bytes,13,rep,name=blob_versioned_hashes,json=blobVersionedHashes,proto3" json:"blob_versioned_hashes,omitempty"`
+	Hash                []byte                 `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
+	BlockNumber         uint64                 `protobuf:"varint,2,opt,name=block_number,json=blockNumber,proto3" json:"block_number,omitempty"`
+	Time                *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=time,proto3" json:"time,omitempty"`
+	From                []byte                 `protobuf:"bytes,4,opt,name=from,proto3" json:"from,omitempty"`
+	To                  []byte                 `protobuf:"bytes,5,opt,name=to,proto3" json:"to,omitempty"`
+	Value               []byte                 `protobuf:"bytes,6,opt,name=value,proto3" json:"value,omitempty"`
+	TxFee               []byte                 `protobuf:"bytes,7,opt,name=tx_fee,json=txFee,proto3" json:"tx_fee,omitempty"`
+	GasPrice            []byte                 `protobuf:"bytes,8,opt,name=gas_price,json=gasPrice,proto3" json:"gas_price,omitempty"`
+	BlobTxFee           []byte                 `protobuf:"bytes,9,opt,name=blob_tx_fee,json=blobTxFee,proto3" json:"blob_tx_fee,omitempty"`
+	BlobGasPrice        []byte                 `protobuf:"bytes,10,opt,name=blob_gas_price,json=blobGasPrice,proto3" json:"blob_gas_price,omitempty"`
+	InvokesContract     bool                   `protobuf:"varint,11,opt,name=invokes_contract,json=invokesContract,proto3" json:"invokes_contract,omitempty"`
+	ErrorMsg            string                 `protobuf:"bytes,12,opt,name=error_msg,json=errorMsg,proto3" json:"error_msg,omitempty"`
+	BlobVersionedHashes [][]byte               `protobuf:"bytes,13,rep,name=blob_versioned_hashes,json=blobVersionedHashes,proto3" json:"blob_versioned_hashes,omitempty"`
 }
 
 func (x *Eth1BlobTransactionIndexed) Reset() {
@@ -1527,7 +1594,7 @@ func (x *Eth1BlobTransactionIndexed) GetBlockNumber() uint64 {
 	return 0
 }
 
-func (x *Eth1BlobTransactionIndexed) GetTime() *timestamp.Timestamp {
+func (x *Eth1BlobTransactionIndexed) GetTime() *timestamppb.Timestamp {
 	if x != nil {
 		return x.Time
 	}
@@ -1583,6 +1650,13 @@ func (x *Eth1BlobTransactionIndexed) GetBlobGasPrice() []byte {
 	return nil
 }
 
+func (x *Eth1BlobTransactionIndexed) GetInvokesContract() bool {
+	if x != nil {
+		return x.InvokesContract
+	}
+	return false
+}
+
 func (x *Eth1BlobTransactionIndexed) GetErrorMsg() string {
 	if x != nil {
 		return x.ErrorMsg
@@ -1602,13 +1676,13 @@ type Eth1ERC20Indexed struct {
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	ParentHash   []byte               `protobuf:"bytes,1,opt,name=parent_hash,json=parentHash,proto3" json:"parent_hash,omitempty"`
-	BlockNumber  uint64               `protobuf:"varint,2,opt,name=block_number,json=blockNumber,proto3" json:"block_number,omitempty"`
-	TokenAddress []byte               `protobuf:"bytes,3,opt,name=token_address,json=tokenAddress,proto3" json:"token_address,omitempty"`
-	Time         *timestamp.Timestamp `protobuf:"bytes,4,opt,name=time,proto3" json:"time,omitempty"`
-	From         []byte               `protobuf:"bytes,5,opt,name=from,proto3" json:"from,omitempty"`
-	To           []byte               `protobuf:"bytes,6,opt,name=to,proto3" json:"to,omitempty"`
-	Value        []byte               `protobuf:"bytes,7,opt,name=value,proto3" json:"value,omitempty"`
+	ParentHash   []byte                 `protobuf:"bytes,1,opt,name=parent_hash,json=parentHash,proto3" json:"parent_hash,omitempty"`
+	BlockNumber  uint64                 `protobuf:"varint,2,opt,name=block_number,json=blockNumber,proto3" json:"block_number,omitempty"`
+	TokenAddress []byte                 `protobuf:"bytes,3,opt,name=token_address,json=tokenAddress,proto3" json:"token_address,omitempty"`
+	Time         *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=time,proto3" json:"time,omitempty"`
+	From         []byte                 `protobuf:"bytes,5,opt,name=from,proto3" json:"from,omitempty"`
+	To           []byte                 `protobuf:"bytes,6,opt,name=to,proto3" json:"to,omitempty"`
+	Value        []byte                 `protobuf:"bytes,7,opt,name=value,proto3" json:"value,omitempty"`
 }
 
 func (x *Eth1ERC20Indexed) Reset() {
@@ -1664,7 +1738,7 @@ func (x *Eth1ERC20Indexed) GetTokenAddress() []byte {
 	return nil
 }
 
-func (x *Eth1ERC20Indexed) GetTime() *timestamp.Timestamp {
+func (x *Eth1ERC20Indexed) GetTime() *timestamppb.Timestamp {
 	if x != nil {
 		return x.Time
 	}
@@ -1697,13 +1771,13 @@ type Eth1ERC721Indexed struct {
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	ParentHash   []byte               `protobuf:"bytes,1,opt,name=parent_hash,json=parentHash,proto3" json:"parent_hash,omitempty"`
-	BlockNumber  uint64               `protobuf:"varint,2,opt,name=block_number,json=blockNumber,proto3" json:"block_number,omitempty"`
-	TokenAddress []byte               `protobuf:"bytes,3,opt,name=token_address,json=tokenAddress,proto3" json:"token_address,omitempty"`
-	Time         *timestamp.Timestamp `protobuf:"bytes,4,opt,name=time,proto3" json:"time,omitempty"`
-	From         []byte               `protobuf:"bytes,5,opt,name=from,proto3" json:"from,omitempty"`
-	To           []byte               `protobuf:"bytes,6,opt,name=to,proto3" json:"to,omitempty"`
-	TokenId      []byte               `protobuf:"bytes,7,opt,name=token_id,json=tokenId,proto3" json:"token_id,omitempty"`
+	ParentHash   []byte                 `protobuf:"bytes,1,opt,name=parent_hash,json=parentHash,proto3" json:"parent_hash,omitempty"`
+	BlockNumber  uint64                 `protobuf:"varint,2,opt,name=block_number,json=blockNumber,proto3" json:"block_number,omitempty"`
+	TokenAddress []byte                 `protobuf:"bytes,3,opt,name=token_address,json=tokenAddress,proto3" json:"token_address,omitempty"`
+	Time         *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=time,proto3" json:"time,omitempty"`
+	From         []byte                 `protobuf:"bytes,5,opt,name=from,proto3" json:"from,omitempty"`
+	To           []byte                 `protobuf:"bytes,6,opt,name=to,proto3" json:"to,omitempty"`
+	TokenId      []byte                 `protobuf:"bytes,7,opt,name=token_id,json=tokenId,proto3" json:"token_id,omitempty"`
 }
 
 func (x *Eth1ERC721Indexed) Reset() {
@@ -1759,7 +1833,7 @@ func (x *Eth1ERC721Indexed) GetTokenAddress() []byte {
 	return nil
 }
 
-func (x *Eth1ERC721Indexed) GetTime() *timestamp.Timestamp {
+func (x *Eth1ERC721Indexed) GetTime() *timestamppb.Timestamp {
 	if x != nil {
 		return x.Time
 	}
@@ -1793,14 +1867,14 @@ type ETh1ERC1155Indexed struct {
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	ParentHash   []byte               `protobuf:"bytes,1,opt,name=parent_hash,json=parentHash,proto3" json:"parent_hash,omitempty"`
-	BlockNumber  uint64               `protobuf:"varint,2,opt,name=block_number,json=blockNumber,proto3" json:"block_number,omitempty"`
-	TokenAddress []byte               `protobuf:"bytes,3,opt,name=token_address,json=tokenAddress,proto3" json:"token_address,omitempty"`
-	Time         *timestamp.Timestamp `protobuf:"bytes,4,opt,name=time,proto3" json:"time,omitempty"`
-	From         []byte               `protobuf:"bytes,5,opt,name=from,proto3" json:"from,omitempty"`
-	To           []byte               `protobuf:"bytes,6,opt,name=to,proto3" json:"to,omitempty"`
-	TokenId      []byte               `protobuf:"bytes,7,opt,name=token_id,json=tokenId,proto3" json:"token_id,omitempty"`
-	Value        []byte               `protobuf:"bytes,8,opt,name=value,proto3" json:"value,omitempty"`
+	ParentHash   []byte                 `protobuf:"bytes,1,opt,name=parent_hash,json=parentHash,proto3" json:"parent_hash,omitempty"`
+	BlockNumber  uint64                 `protobuf:"varint,2,opt,name=block_number,json=blockNumber,proto3" json:"block_number,omitempty"`
+	TokenAddress []byte                 `protobuf:"bytes,3,opt,name=token_address,json=tokenAddress,proto3" json:"token_address,omitempty"`
+	Time         *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=time,proto3" json:"time,omitempty"`
+	From         []byte                 `protobuf:"bytes,5,opt,name=from,proto3" json:"from,omitempty"`
+	To           []byte                 `protobuf:"bytes,6,opt,name=to,proto3" json:"to,omitempty"`
+	TokenId      []byte                 `protobuf:"bytes,7,opt,name=token_id,json=tokenId,proto3" json:"token_id,omitempty"`
+	Value        []byte                 `protobuf:"bytes,8,opt,name=value,proto3" json:"value,omitempty"`
 	// the address approved to make the transfer
 	Operator []byte `protobuf:"bytes,9,opt,name=operator,proto3" json:"operator,omitempty"`
 }
@@ -1858,7 +1932,7 @@ func (x *ETh1ERC1155Indexed) GetTokenAddress() []byte {
 	return nil
 }
 
-func (x *ETh1ERC1155Indexed) GetTime() *timestamp.Timestamp {
+func (x *ETh1ERC1155Indexed) GetTime() *timestamppb.Timestamp {
 	if x != nil {
 		return x.Time
 	}
@@ -2115,7 +2189,7 @@ var file_eth1_proto_rawDesc = []byte{
 	0x75, 0x6e, 0x74, 0x12, 0x2e, 0x0a, 0x04, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28,
 	0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
 	0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x04, 0x74,
-	0x69, 0x6d, 0x65, 0x22, 0xca, 0x03, 0x0a, 0x16, 0x45, 0x74, 0x68, 0x31, 0x54, 0x72, 0x61, 0x6e,
+	0x69, 0x6d, 0x65, 0x22, 0xf5, 0x03, 0x0a, 0x16, 0x45, 0x74, 0x68, 0x31, 0x54, 0x72, 0x61, 0x6e,
 	0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x65, 0x64, 0x12, 0x12,
 	0x0a, 0x04, 0x68, 0x61, 0x73, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x68, 0x61,
 	0x73, 0x68, 0x12, 0x21, 0x0a, 0x0c, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x6e, 0x75, 0x6d, 0x62,
@@ -2144,93 +2218,103 @@ var file_eth1_proto_rawDesc = []byte{
 	0x09, 0x62, 0x6c, 0x6f, 0x62, 0x54, 0x78, 0x46, 0x65, 0x65, 0x12, 0x24, 0x0a, 0x0e, 0x62, 0x6c,
 	0x6f, 0x62, 0x5f, 0x67, 0x61, 0x73, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x0e, 0x20, 0x01,
 	0x28, 0x0c, 0x52, 0x0c, 0x62, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65,
-	0x22, 0xe2, 0x01, 0x0a, 0x1e, 0x45, 0x74, 0x68, 0x31, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61,
-	0x6c, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x64, 0x65,
-	0x78, 0x65, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x68, 0x61,
-	0x73, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74,
-	0x48, 0x61, 0x73, 0x68, 0x12, 0x21, 0x0a, 0x0c, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x6e, 0x75,
-	0x6d, 0x62, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x62, 0x6c, 0x6f, 0x63,
-	0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18,
-	0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x2e, 0x0a, 0x04, 0x74,
-	0x69, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
-	0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65,
-	0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x04, 0x74, 0x69, 0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x66,
-	0x72, 0x6f, 0x6d, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x66, 0x72, 0x6f, 0x6d, 0x12,
-	0x0e, 0x0a, 0x02, 0x74, 0x6f, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x02, 0x74, 0x6f, 0x12,
-	0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05,
-	0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x8e, 0x03, 0x0a, 0x1a, 0x45, 0x74, 0x68, 0x31, 0x42, 0x6c,
-	0x6f, 0x62, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x64,
-	0x65, 0x78, 0x65, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x68, 0x61, 0x73, 0x68, 0x18, 0x01, 0x20, 0x01,
-	0x28, 0x0c, 0x52, 0x04, 0x68, 0x61, 0x73, 0x68, 0x12, 0x21, 0x0a, 0x0c, 0x62, 0x6c, 0x6f, 0x63,
+	0x12, 0x29, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0e,
+	0x32, 0x11, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x54,
+	0x79, 0x70, 0x65, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0xfe, 0x01, 0x0a, 0x1e,
+	0x45, 0x74, 0x68, 0x31, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x54, 0x72, 0x61, 0x6e,
+	0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x65, 0x64, 0x12, 0x1f,
+	0x0a, 0x0b, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x0c, 0x52, 0x0a, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, 0x68, 0x12,
+	0x21, 0x0a, 0x0c, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x18,
+	0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62,
+	0x65, 0x72, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x2e, 0x0a, 0x04, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x04,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70,
+	0x52, 0x04, 0x74, 0x69, 0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x66, 0x72, 0x6f, 0x6d, 0x18, 0x05,
+	0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x66, 0x72, 0x6f, 0x6d, 0x12, 0x0e, 0x0a, 0x02, 0x74, 0x6f,
+	0x18, 0x06, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x02, 0x74, 0x6f, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61,
+	0x6c, 0x75, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65,
+	0x12, 0x1a, 0x0a, 0x08, 0x72, 0x65, 0x76, 0x65, 0x72, 0x74, 0x65, 0x64, 0x18, 0x08, 0x20, 0x01,
+	0x28, 0x08, 0x52, 0x08, 0x72, 0x65, 0x76, 0x65, 0x72, 0x74, 0x65, 0x64, 0x22, 0xb3, 0x03, 0x0a,
+	0x1a, 0x45, 0x74, 0x68, 0x31, 0x42, 0x6c, 0x6f, 0x62, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63,
+	0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x65, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x68,
+	0x61, 0x73, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x68, 0x61, 0x73, 0x68, 0x12,
+	0x21, 0x0a, 0x0c, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x18,
+	0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62,
+	0x65, 0x72, 0x12, 0x2e, 0x0a, 0x04, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
+	0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x04, 0x74, 0x69,
+	0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x66, 0x72, 0x6f, 0x6d, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c,
+	0x52, 0x04, 0x66, 0x72, 0x6f, 0x6d, 0x12, 0x0e, 0x0a, 0x02, 0x74, 0x6f, 0x18, 0x05, 0x20, 0x01,
+	0x28, 0x0c, 0x52, 0x02, 0x74, 0x6f, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18,
+	0x06, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x15, 0x0a, 0x06,
+	0x74, 0x78, 0x5f, 0x66, 0x65, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x74, 0x78,
+	0x46, 0x65, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x67, 0x61, 0x73, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65,
+	0x18, 0x08, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x67, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65,
+	0x12, 0x1e, 0x0a, 0x0b, 0x62, 0x6c, 0x6f, 0x62, 0x5f, 0x74, 0x78, 0x5f, 0x66, 0x65, 0x65, 0x18,
+	0x09, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x62, 0x6c, 0x6f, 0x62, 0x54, 0x78, 0x46, 0x65, 0x65,
+	0x12, 0x24, 0x0a, 0x0e, 0x62, 0x6c, 0x6f, 0x62, 0x5f, 0x67, 0x61, 0x73, 0x5f, 0x70, 0x72, 0x69,
+	0x63, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0c, 0x62, 0x6c, 0x6f, 0x62, 0x47, 0x61,
+	0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x12, 0x29, 0x0a, 0x10, 0x69, 0x6e, 0x76, 0x6f, 0x6b, 0x65,
+	0x73, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x08,
+	0x52, 0x0f, 0x69, 0x6e, 0x76, 0x6f, 0x6b, 0x65, 0x73, 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63,
+	0x74, 0x12, 0x1b, 0x0a, 0x09, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x5f, 0x6d, 0x73, 0x67, 0x18, 0x0c,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x4d, 0x73, 0x67, 0x12, 0x32,
+	0x0a, 0x15, 0x62, 0x6c, 0x6f, 0x62, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64,
+	0x5f, 0x68, 0x61, 0x73, 0x68, 0x65, 0x73, 0x18, 0x0d, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x13, 0x62,
+	0x6c, 0x6f, 0x62, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x48, 0x61, 0x73, 0x68,
+	0x65, 0x73, 0x22, 0xe5, 0x01, 0x0a, 0x10, 0x45, 0x74, 0x68, 0x31, 0x45, 0x52, 0x43, 0x32, 0x30,
+	0x49, 0x6e, 0x64, 0x65, 0x78, 0x65, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x61, 0x72, 0x65, 0x6e,
+	0x74, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x70, 0x61,
+	0x72, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, 0x68, 0x12, 0x21, 0x0a, 0x0c, 0x62, 0x6c, 0x6f, 0x63,
 	0x6b, 0x5f, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0b,
-	0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x12, 0x2e, 0x0a, 0x04, 0x74,
-	0x69, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
-	0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65,
-	0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x04, 0x74, 0x69, 0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x66,
-	0x72, 0x6f, 0x6d, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x66, 0x72, 0x6f, 0x6d, 0x12,
-	0x0e, 0x0a, 0x02, 0x74, 0x6f, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x02, 0x74, 0x6f, 0x12,
-	0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05,
-	0x76, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x15, 0x0a, 0x06, 0x74, 0x78, 0x5f, 0x66, 0x65, 0x65, 0x18,
-	0x07, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x74, 0x78, 0x46, 0x65, 0x65, 0x12, 0x1b, 0x0a, 0x09,
-	0x67, 0x61, 0x73, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0c, 0x52,
-	0x08, 0x67, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x12, 0x1e, 0x0a, 0x0b, 0x62, 0x6c, 0x6f,
-	0x62, 0x5f, 0x74, 0x78, 0x5f, 0x66, 0x65, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09,
-	0x62, 0x6c, 0x6f, 0x62, 0x54, 0x78, 0x46, 0x65, 0x65, 0x12, 0x24, 0x0a, 0x0e, 0x62, 0x6c, 0x6f,
-	0x62, 0x5f, 0x67, 0x61, 0x73, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28,
-	0x0c, 0x52, 0x0c, 0x62, 0x6c, 0x6f, 0x62, 0x47, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x12,
-	0x1b, 0x0a, 0x09, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x5f, 0x6d, 0x73, 0x67, 0x18, 0x0c, 0x20, 0x01,
-	0x28, 0x09, 0x52, 0x08, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x4d, 0x73, 0x67, 0x12, 0x32, 0x0a, 0x15,
-	0x62, 0x6c, 0x6f, 0x62, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x5f, 0x68,
-	0x61, 0x73, 0x68, 0x65, 0x73, 0x18, 0x0d, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x13, 0x62, 0x6c, 0x6f,
-	0x62, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x65, 0x64, 0x48, 0x61, 0x73, 0x68, 0x65, 0x73,
-	0x4a, 0x04, 0x08, 0x0b, 0x10, 0x0c, 0x22, 0xe5, 0x01, 0x0a, 0x10, 0x45, 0x74, 0x68, 0x31, 0x45,
-	0x52, 0x43, 0x32, 0x30, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x65, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x70,
-	0x61, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c,
-	0x52, 0x0a, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, 0x68, 0x12, 0x21, 0x0a, 0x0c,
-	0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01,
-	0x28, 0x04, 0x52, 0x0b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x12,
-	0x23, 0x0a, 0x0d, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73,
-	0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0c, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x41, 0x64, 0x64,
-	0x72, 0x65, 0x73, 0x73, 0x12, 0x2e, 0x0a, 0x04, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01,
-	0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74,
-	0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x04,
-	0x74, 0x69, 0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x66, 0x72, 0x6f, 0x6d, 0x18, 0x05, 0x20, 0x01,
-	0x28, 0x0c, 0x52, 0x04, 0x66, 0x72, 0x6f, 0x6d, 0x12, 0x0e, 0x0a, 0x02, 0x74, 0x6f, 0x18, 0x06,
-	0x20, 0x01, 0x28, 0x0c, 0x52, 0x02, 0x74, 0x6f, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75,
-	0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0xeb,
-	0x01, 0x0a, 0x11, 0x45, 0x74, 0x68, 0x31, 0x45, 0x52, 0x43, 0x37, 0x32, 0x31, 0x49, 0x6e, 0x64,
-	0x65, 0x78, 0x65, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x68,
-	0x61, 0x73, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x70, 0x61, 0x72, 0x65, 0x6e,
-	0x74, 0x48, 0x61, 0x73, 0x68, 0x12, 0x21, 0x0a, 0x0c, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x6e,
-	0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x62, 0x6c, 0x6f,
-	0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x12, 0x23, 0x0a, 0x0d, 0x74, 0x6f, 0x6b, 0x65,
-	0x6e, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52,
-	0x0c, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x2e, 0x0a,
-	0x04, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f,
-	0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69,
-	0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x04, 0x74, 0x69, 0x6d, 0x65, 0x12, 0x12, 0x0a,
-	0x04, 0x66, 0x72, 0x6f, 0x6d, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x66, 0x72, 0x6f,
-	0x6d, 0x12, 0x0e, 0x0a, 0x02, 0x74, 0x6f, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x02, 0x74,
-	0x6f, 0x12, 0x19, 0x0a, 0x08, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x07, 0x20,
-	0x01, 0x28, 0x0c, 0x52, 0x07, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x49, 0x64, 0x22, 0x9e, 0x02, 0x0a,
-	0x12, 0x45, 0x54, 0x68, 0x31, 0x45, 0x52, 0x43, 0x31, 0x31, 0x35, 0x35, 0x49, 0x6e, 0x64, 0x65,
-	0x78, 0x65, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x68, 0x61,
-	0x73, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74,
-	0x48, 0x61, 0x73, 0x68, 0x12, 0x21, 0x0a, 0x0c, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x6e, 0x75,
-	0x6d, 0x62, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x62, 0x6c, 0x6f, 0x63,
-	0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x12, 0x23, 0x0a, 0x0d, 0x74, 0x6f, 0x6b, 0x65, 0x6e,
-	0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0c,
-	0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x2e, 0x0a, 0x04,
-	0x74, 0x69, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f,
-	0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d,
-	0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x04, 0x74, 0x69, 0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04,
-	0x66, 0x72, 0x6f, 0x6d, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x66, 0x72, 0x6f, 0x6d,
-	0x12, 0x0e, 0x0a, 0x02, 0x74, 0x6f, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x02, 0x74, 0x6f,
-	0x12, 0x19, 0x0a, 0x08, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x07, 0x20, 0x01,
-	0x28, 0x0c, 0x52, 0x07, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x49, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x76,
-	0x61, 0x6c, 0x75, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75,
-	0x65, 0x12, 0x1a, 0x0a, 0x08, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x09, 0x20,
-	0x01, 0x28, 0x0c, 0x52, 0x08, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x42, 0x09, 0x5a,
+	0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x12, 0x23, 0x0a, 0x0d, 0x74,
+	0x6f, 0x6b, 0x65, 0x6e, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x03, 0x20, 0x01,
+	0x28, 0x0c, 0x52, 0x0c, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73,
+	0x12, 0x2e, 0x0a, 0x04, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a,
+	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66,
+	0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x04, 0x74, 0x69, 0x6d, 0x65,
+	0x12, 0x12, 0x0a, 0x04, 0x66, 0x72, 0x6f, 0x6d, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04,
+	0x66, 0x72, 0x6f, 0x6d, 0x12, 0x0e, 0x0a, 0x02, 0x74, 0x6f, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0c,
+	0x52, 0x02, 0x74, 0x6f, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x07, 0x20,
+	0x01, 0x28, 0x0c, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0xeb, 0x01, 0x0a, 0x11, 0x45,
+	0x74, 0x68, 0x31, 0x45, 0x52, 0x43, 0x37, 0x32, 0x31, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x65, 0x64,
+	0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73,
+	0x68, 0x12, 0x21, 0x0a, 0x0c, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x6e, 0x75, 0x6d, 0x62, 0x65,
+	0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75,
+	0x6d, 0x62, 0x65, 0x72, 0x12, 0x23, 0x0a, 0x0d, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x5f, 0x61, 0x64,
+	0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0c, 0x74, 0x6f, 0x6b,
+	0x65, 0x6e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x2e, 0x0a, 0x04, 0x74, 0x69, 0x6d,
+	0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74,
+	0x61, 0x6d, 0x70, 0x52, 0x04, 0x74, 0x69, 0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x66, 0x72, 0x6f,
+	0x6d, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x66, 0x72, 0x6f, 0x6d, 0x12, 0x0e, 0x0a,
+	0x02, 0x74, 0x6f, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x02, 0x74, 0x6f, 0x12, 0x19, 0x0a,
+	0x08, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0c, 0x52,
+	0x07, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x49, 0x64, 0x22, 0x9e, 0x02, 0x0a, 0x12, 0x45, 0x54, 0x68,
+	0x31, 0x45, 0x52, 0x43, 0x31, 0x31, 0x35, 0x35, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x65, 0x64, 0x12,
+	0x1f, 0x0a, 0x0b, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73, 0x68,
+	0x12, 0x21, 0x0a, 0x0c, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72,
+	0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d,
+	0x62, 0x65, 0x72, 0x12, 0x23, 0x0a, 0x0d, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x5f, 0x61, 0x64, 0x64,
+	0x72, 0x65, 0x73, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0c, 0x74, 0x6f, 0x6b, 0x65,
+	0x6e, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x2e, 0x0a, 0x04, 0x74, 0x69, 0x6d, 0x65,
+	0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61,
+	0x6d, 0x70, 0x52, 0x04, 0x74, 0x69, 0x6d, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x66, 0x72, 0x6f, 0x6d,
+	0x18, 0x05, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x66, 0x72, 0x6f, 0x6d, 0x12, 0x0e, 0x0a, 0x02,
+	0x74, 0x6f, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x02, 0x74, 0x6f, 0x12, 0x19, 0x0a, 0x08,
+	0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x07,
+	0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x49, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65,
+	0x18, 0x08, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x1a, 0x0a,
+	0x08, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0c, 0x52,
+	0x08, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x2a, 0x32, 0x0a, 0x0a, 0x53, 0x74, 0x61,
+	0x74, 0x75, 0x73, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0a, 0x0a, 0x06, 0x46, 0x41, 0x49, 0x4c, 0x45,
+	0x44, 0x10, 0x00, 0x12, 0x0b, 0x0a, 0x07, 0x53, 0x55, 0x43, 0x43, 0x45, 0x53, 0x53, 0x10, 0x01,
+	0x12, 0x0b, 0x0a, 0x07, 0x50, 0x41, 0x52, 0x54, 0x49, 0x41, 0x4c, 0x10, 0x02, 0x42, 0x09, 0x5a,
 	0x07, 0x2e, 0x2f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 }
 
@@ -2246,48 +2330,51 @@ func file_eth1_proto_rawDescGZIP() []byte {
 	return file_eth1_proto_rawDescData
 }
 
+var file_eth1_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
 var file_eth1_proto_msgTypes = make([]protoimpl.MessageInfo, 16)
 var file_eth1_proto_goTypes = []interface{}{
-	(*Eth1Block)(nil),                      // 0: types.Eth1Block
-	(*Eth1Withdrawal)(nil),                 // 1: types.Eth1Withdrawal
-	(*Eth1Transaction)(nil),                // 2: types.Eth1Transaction
-	(*IsContractUpdate)(nil),               // 3: types.IsContractUpdate
-	(*AccessList)(nil),                     // 4: types.AccessList
-	(*Eth1Log)(nil),                        // 5: types.Eth1Log
-	(*Eth1InternalTransaction)(nil),        // 6: types.Eth1InternalTransaction
-	(*Eth1BlockIndexed)(nil),               // 7: types.Eth1BlockIndexed
-	(*Eth1UncleIndexed)(nil),               // 8: types.Eth1UncleIndexed
-	(*Eth1WithdrawalIndexed)(nil),          // 9: types.Eth1WithdrawalIndexed
-	(*Eth1TransactionIndexed)(nil),         // 10: types.Eth1TransactionIndexed
-	(*Eth1InternalTransactionIndexed)(nil), // 11: types.Eth1InternalTransactionIndexed
-	(*Eth1BlobTransactionIndexed)(nil),     // 12: types.Eth1BlobTransactionIndexed
-	(*Eth1ERC20Indexed)(nil),               // 13: types.Eth1ERC20Indexed
-	(*Eth1ERC721Indexed)(nil),              // 14: types.Eth1ERC721Indexed
-	(*ETh1ERC1155Indexed)(nil),             // 15: types.ETh1ERC1155Indexed
-	(*timestamp.Timestamp)(nil),            // 16: google.protobuf.Timestamp
+	(StatusType)(0),                        // 0: types.StatusType
+	(*Eth1Block)(nil),                      // 1: types.Eth1Block
+	(*Eth1Withdrawal)(nil),                 // 2: types.Eth1Withdrawal
+	(*Eth1Transaction)(nil),                // 3: types.Eth1Transaction
+	(*IsContractUpdate)(nil),               // 4: types.IsContractUpdate
+	(*AccessList)(nil),                     // 5: types.AccessList
+	(*Eth1Log)(nil),                        // 6: types.Eth1Log
+	(*Eth1InternalTransaction)(nil),        // 7: types.Eth1InternalTransaction
+	(*Eth1BlockIndexed)(nil),               // 8: types.Eth1BlockIndexed
+	(*Eth1UncleIndexed)(nil),               // 9: types.Eth1UncleIndexed
+	(*Eth1WithdrawalIndexed)(nil),          // 10: types.Eth1WithdrawalIndexed
+	(*Eth1TransactionIndexed)(nil),         // 11: types.Eth1TransactionIndexed
+	(*Eth1InternalTransactionIndexed)(nil), // 12: types.Eth1InternalTransactionIndexed
+	(*Eth1BlobTransactionIndexed)(nil),     // 13: types.Eth1BlobTransactionIndexed
+	(*Eth1ERC20Indexed)(nil),               // 14: types.Eth1ERC20Indexed
+	(*Eth1ERC721Indexed)(nil),              // 15: types.Eth1ERC721Indexed
+	(*ETh1ERC1155Indexed)(nil),             // 16: types.ETh1ERC1155Indexed
+	(*timestamppb.Timestamp)(nil),          // 17: google.protobuf.Timestamp
 }
 var file_eth1_proto_depIdxs = []int32{
-	16, // 0: types.Eth1Block.time:type_name -> google.protobuf.Timestamp
-	0,  // 1: types.Eth1Block.uncles:type_name -> types.Eth1Block
-	2,  // 2: types.Eth1Block.transactions:type_name -> types.Eth1Transaction
-	1,  // 3: types.Eth1Block.withdrawals:type_name -> types.Eth1Withdrawal
-	4,  // 4: types.Eth1Transaction.access_list:type_name -> types.AccessList
-	5,  // 5: types.Eth1Transaction.logs:type_name -> types.Eth1Log
-	6,  // 6: types.Eth1Transaction.itx:type_name -> types.Eth1InternalTransaction
-	16, // 7: types.Eth1BlockIndexed.time:type_name -> google.protobuf.Timestamp
-	16, // 8: types.Eth1UncleIndexed.time:type_name -> google.protobuf.Timestamp
-	16, // 9: types.Eth1WithdrawalIndexed.time:type_name -> google.protobuf.Timestamp
-	16, // 10: types.Eth1TransactionIndexed.time:type_name -> google.protobuf.Timestamp
-	16, // 11: types.Eth1InternalTransactionIndexed.time:type_name -> google.protobuf.Timestamp
-	16, // 12: types.Eth1BlobTransactionIndexed.time:type_name -> google.protobuf.Timestamp
-	16, // 13: types.Eth1ERC20Indexed.time:type_name -> google.protobuf.Timestamp
-	16, // 14: types.Eth1ERC721Indexed.time:type_name -> google.protobuf.Timestamp
-	16, // 15: types.ETh1ERC1155Indexed.time:type_name -> google.protobuf.Timestamp
-	16, // [16:16] is the sub-list for method output_type
-	16, // [16:16] is the sub-list for method input_type
-	16, // [16:16] is the sub-list for extension type_name
-	16, // [16:16] is the sub-list for extension extendee
-	0,  // [0:16] is the sub-list for field type_name
+	17, // 0: types.Eth1Block.time:type_name -> google.protobuf.Timestamp
+	1,  // 1: types.Eth1Block.uncles:type_name -> types.Eth1Block
+	3,  // 2: types.Eth1Block.transactions:type_name -> types.Eth1Transaction
+	2,  // 3: types.Eth1Block.withdrawals:type_name -> types.Eth1Withdrawal
+	5,  // 4: types.Eth1Transaction.access_list:type_name -> types.AccessList
+	6,  // 5: types.Eth1Transaction.logs:type_name -> types.Eth1Log
+	7,  // 6: types.Eth1Transaction.itx:type_name -> types.Eth1InternalTransaction
+	17, // 7: types.Eth1BlockIndexed.time:type_name -> google.protobuf.Timestamp
+	17, // 8: types.Eth1UncleIndexed.time:type_name -> google.protobuf.Timestamp
+	17, // 9: types.Eth1WithdrawalIndexed.time:type_name -> google.protobuf.Timestamp
+	17, // 10: types.Eth1TransactionIndexed.time:type_name -> google.protobuf.Timestamp
+	0,  // 11: types.Eth1TransactionIndexed.status:type_name -> types.StatusType
+	17, // 12: types.Eth1InternalTransactionIndexed.time:type_name -> google.protobuf.Timestamp
+	17, // 13: types.Eth1BlobTransactionIndexed.time:type_name -> google.protobuf.Timestamp
+	17, // 14: types.Eth1ERC20Indexed.time:type_name -> google.protobuf.Timestamp
+	17, // 15: types.Eth1ERC721Indexed.time:type_name -> google.protobuf.Timestamp
+	17, // 16: types.ETh1ERC1155Indexed.time:type_name -> google.protobuf.Timestamp
+	17, // [17:17] is the sub-list for method output_type
+	17, // [17:17] is the sub-list for method input_type
+	17, // [17:17] is the sub-list for extension type_name
+	17, // [17:17] is the sub-list for extension extendee
+	0,  // [0:17] is the sub-list for field type_name
 }
 
 func init() { file_eth1_proto_init() }
@@ -2494,13 +2581,14 @@ func file_eth1_proto_init() {
 		File: protoimpl.DescBuilder{
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
 			RawDescriptor: file_eth1_proto_rawDesc,
-			NumEnums:      0,
+			NumEnums:      1,
 			NumMessages:   16,
 			NumExtensions: 0,
 			NumServices:   0,
 		},
 		GoTypes:           file_eth1_proto_goTypes,
 		DependencyIndexes: file_eth1_proto_depIdxs,
+		EnumInfos:         file_eth1_proto_enumTypes,
 		MessageInfos:      file_eth1_proto_msgTypes,
 	}.Build()
 	File_eth1_proto = out.File
diff --git a/backend/pkg/commons/types/eth1.proto b/backend/pkg/commons/types/eth1.proto
index c6782edfc..c1a7ff9ad 100644
--- a/backend/pkg/commons/types/eth1.proto
+++ b/backend/pkg/commons/types/eth1.proto
@@ -64,7 +64,9 @@ message Eth1Transaction {
     uint64 gas_used = 19;
     bytes logs_bloom = 20;
     uint64 status = 21;
+    //reserved 22; // string error_msg = 22;
     string error_msg = 22;
+
     repeated Eth1Log logs = 23;
 
     // Internal transactions
@@ -78,6 +80,11 @@ message Eth1Transaction {
     uint64 blob_gas_used = 28;
 }
 
+message IsContractUpdate {
+    bool is_contract = 1;
+    bool success = 2;
+}
+
 message AccessList {
     bytes address = 1;
     repeated bytes storage_keys = 2;
@@ -150,6 +157,12 @@ message Eth1WithdrawalIndexed {
     google.protobuf.Timestamp time = 6;
 }
 
+enum StatusType {
+    FAILED = 0;
+    SUCCESS = 1;
+    PARTIAL = 2;
+}
+
 message Eth1TransactionIndexed {
     bytes hash = 1;
     uint64 block_number = 2;
@@ -161,12 +174,15 @@ message Eth1TransactionIndexed {
     bytes tx_fee = 8;
     bytes gas_price = 9;
     bool is_contract_creation = 10;
+//    reserved 11; // bool invokes_contract = 11;
     bool invokes_contract = 11;
     string error_msg = 12;
 
     // EIP 4844
     bytes blob_tx_fee = 13;
     bytes blob_gas_price = 14;
+
+    StatusType status = 15;
 }
 
 message Eth1InternalTransactionIndexed {
@@ -177,6 +193,7 @@ message Eth1InternalTransactionIndexed {
     bytes from = 5;
     bytes to = 6;
     bytes value = 7;
+    bool reverted = 8;
 }
 
 // https://eips.ethereum.org/EIPS/eip-4844