diff --git a/backend/cmd/store/main.go b/backend/cmd/store/main.go
new file mode 100644
index 000000000..279723a7e
--- /dev/null
+++ b/backend/cmd/store/main.go
@@ -0,0 +1,31 @@
+package main
+
+import (
+	"errors"
+	"net/http"
+	"os"
+
+	"github.com/gobitfly/beaconchain/pkg/commons/db2/database"
+	"github.com/gobitfly/beaconchain/pkg/commons/log"
+	"github.com/gobitfly/beaconchain/pkg/commons/utils"
+)
+
+func main() {
+	args := os.Args[1:]
+	project := args[0]
+	instance := args[1]
+	table := args[2]
+
+	bt, err := database.NewBigTable(project, instance, nil)
+	if err != nil {
+		panic(err)
+	}
+	remote := database.NewRemote(database.Wrap(bt, table))
+	go func() {
+		log.Info("starting remote raw store on port 8087")
+		if err := http.ListenAndServe("0.0.0.0:8087", remote.Routes()); err != nil && !errors.Is(err, http.ErrServerClosed) {
+			panic(err)
+		}
+	}()
+	utils.WaitForCtrlC()
+}
diff --git a/backend/pkg/commons/db2/data/data.go b/backend/pkg/commons/db2/data/data.go
new file mode 100644
index 000000000..24879dc01
--- /dev/null
+++ b/backend/pkg/commons/db2/data/data.go
@@ -0,0 +1,278 @@
+package data
+
+import (
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"sort"
+	"strings"
+	"time"
+
+	"github.com/ethereum/go-ethereum/common"
+	"golang.org/x/exp/maps"
+	"google.golang.org/protobuf/proto"
+
+	"github.com/gobitfly/beaconchain/pkg/commons/db2/database"
+	"github.com/gobitfly/beaconchain/pkg/commons/types"
+)
+
+type Store struct {
+	db database.Database
+}
+
+func NewStore(store database.Database) Store {
+	return Store{
+		db: 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) AddBlockERC20Transfers(chainID string, transactions []TransferWithIndexes) error {
+	items, err := store.BlockERC20TransfersToItems(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)
+	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,
+	}
+	options := apply(opts)
+	if options.ignoreTxs {
+		delete(sources, typeTx)
+	}
+	if options.ignoreTransfers {
+		delete(sources, typeTransfer)
+	}
+	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...)
+	}
+	sort.Sort(byTimeDesc(interactions))
+	if int64(len(interactions)) > limit {
+		interactions = interactions[:limit]
+	}
+
+	var res []*Interaction
+	if prefixes == nil {
+		prefixes = make(map[string]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
+		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) {
+	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]
+			}
+			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
+			}
+			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 {
+				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],
+				})
+			}
+		}
+	}
+	return interactions, nil
+}
+
+type interactionWithInfo struct {
+	*Interaction
+	chainID string
+	root    string
+	key     string
+}
+
+type byTimeDesc []*interactionWithInfo
+
+func (c byTimeDesc) Len() int      { return len(c) }
+func (c byTimeDesc) Swap(i, j int) { c[i], c[j] = c[j], c[i] }
+func (c byTimeDesc) Less(i, j int) bool {
+	t1 := c[i].Interaction.Time
+	t2 := c[j].Interaction.Time
+	if t1.Equal(t2) {
+		return c[i].key < c[j].key
+	}
+	return t1.After(t2)
+}
+
+type Interaction struct {
+	ChainID string
+	Hash    []byte
+	Method  []byte
+	Time    time.Time
+	Type    string
+	Value   []byte
+	Asset   string
+	From    string
+	To      string
+}
+
+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 {
+		return nil, err
+	}
+	return parseTx(tx), nil
+}
+
+func unMarshalTransfer(b []byte) (*Interaction, error) {
+	tx := &types.Eth1ERC20Indexed{}
+	if err := proto.Unmarshal(b, tx); err != nil {
+		return nil, err
+	}
+	return parseTransfer(tx), nil
+}
+
+func parseTransfer(transfer *types.Eth1ERC20Indexed) *Interaction {
+	return &Interaction{
+		ChainID: "",
+		Hash:    transfer.ParentHash,
+		Method:  erc20Transfer,
+		Time:    transfer.Time.AsTime(),
+		Type:    "ERC20",
+		Value:   transfer.Value,
+		Asset:   hex.EncodeToString(transfer.TokenAddress),
+		From:    hex.EncodeToString(transfer.From),
+		To:      hex.EncodeToString(transfer.To),
+	}
+}
+
+func parseTx(tx *types.Eth1TransactionIndexed) *Interaction {
+	return &Interaction{
+		ChainID: "",
+		Hash:    tx.Hash,
+		Method:  tx.MethodId,
+		Time:    tx.Time.AsTime(),
+		Type:    "Transaction",
+		Value:   tx.Value,
+		Asset:   "ETH",
+		From:    hex.EncodeToString(tx.From),
+		To:      hex.EncodeToString(tx.To),
+	}
+}
diff --git a/backend/pkg/commons/db2/data/data_external_test.go b/backend/pkg/commons/db2/data/data_external_test.go
new file mode 100644
index 000000000..04afd2bd3
--- /dev/null
+++ b/backend/pkg/commons/db2/data/data_external_test.go
@@ -0,0 +1,109 @@
+package data_test
+
+import (
+	"encoding/hex"
+	"os"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common"
+
+	"github.com/gobitfly/beaconchain/pkg/commons/db2/data"
+	"github.com/gobitfly/beaconchain/pkg/commons/db2/database"
+)
+
+var chainIDs = []string{
+	"1",
+	"17000",
+	"100",
+}
+
+var addresses = []common.Address{
+	common.HexToAddress("0x95222290DD7278Aa3Ddd389Cc1E1d165CC4BAfe5"),
+	common.HexToAddress("0x388C818CA8B9251b393131C08a736A67ccB19297"),
+	common.HexToAddress("0x6d2e03b7EfFEae98BD302A9F836D0d6Ab0002766"),
+	common.HexToAddress("0x10e4597ff93cbee194f4879f8f1d54a370db6969"),
+}
+
+func dbFromEnv(t *testing.T, table string) database.Database {
+	project := os.Getenv("BIGTABLE_PROJECT")
+	instance := os.Getenv("BIGTABLE_INSTANCE")
+	remote := os.Getenv("REMOTE_URL")
+	if project != "" && instance != "" {
+		db, err := database.NewBigTable(project, instance, nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		return database.Wrap(db, table)
+	}
+	if remote != "" {
+		return database.NewRemoteClient(remote)
+	}
+	t.Skip("skipping test, set BIGTABLE_PROJECT and BIGTABLE_INSTANCE or REMOTE_URL")
+	return nil
+}
+
+func TestStoreExternal(t *testing.T) {
+	db := dbFromEnv(t, data.Table)
+	store := data.NewStore(db)
+
+	/*
+		list of filter
+		data.ByMethod(method)
+		data.ByAsset(asset)
+		data.OnlyReceived()
+		data.OnlySent()
+		data.IgnoreTransactions()
+		data.IgnoreTransfers()
+		data.WithTimeRange(from, to)
+	*/
+	tests := []struct {
+		name      string
+		limit     int64
+		chainIDs  []string
+		scroll    int
+		addresses []common.Address
+		opts      []data.Option
+	}{
+		{
+			name:      "all no filter",
+			limit:     25,
+			scroll:    2,
+			chainIDs:  chainIDs,
+			addresses: addresses,
+		},
+		{
+			name:      "tx with erc20 transfer method",
+			limit:     10,
+			chainIDs:  chainIDs,
+			addresses: addresses,
+			opts: []data.Option{
+				data.IgnoreTransfers(),
+				data.ByMethod("a9059cbb"),
+			},
+		},
+		{
+			name:      "transfer",
+			limit:     10,
+			chainIDs:  chainIDs,
+			addresses: addresses,
+			opts: []data.Option{
+				data.IgnoreTransactions(),
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var lastPrefixes map[string]map[string]string
+			for i := 0; i < tt.scroll+1; i++ {
+				interactions, prefixes, err := store.Get(chainIDs, addresses, lastPrefixes, tt.limit, tt.opts...)
+				if err != nil {
+					t.Fatal(err)
+				}
+				for _, interaction := range interactions {
+					t.Log(interaction.ChainID, "0x"+interaction.From, "0x"+interaction.To, "0x"+hex.EncodeToString(interaction.Hash), interaction.Time)
+				}
+				lastPrefixes = prefixes
+			}
+		})
+	}
+}
diff --git a/backend/pkg/commons/db2/data/data_test.go b/backend/pkg/commons/db2/data/data_test.go
new file mode 100644
index 000000000..0942331a6
--- /dev/null
+++ b/backend/pkg/commons/db2/data/data_test.go
@@ -0,0 +1,360 @@
+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"
+	"github.com/gobitfly/beaconchain/pkg/commons/db2/databasetest"
+	"github.com/gobitfly/beaconchain/pkg/commons/types"
+)
+
+var (
+	alice = common.HexToAddress("0x000000000000000000000000000000000000abba")
+	bob   = common.HexToAddress("0x000000000000000000000000000000000000beef")
+	carl  = common.HexToAddress("0x000000000000000000000000000000000000cafe")
+	usdc  = common.HexToAddress("0x000000000000000000000000000000000000dead")
+)
+
+func TestStore(t *testing.T) {
+	client, admin := databasetest.NewBigTable(t)
+
+	s, err := database.NewBigTableWithClient(context.Background(), client, admin, Schema)
+	if err != nil {
+		t.Fatal(err)
+	}
+	store := Store{
+		db: database.Wrap(s, Table),
+	}
+
+	tests := []struct {
+		name           string
+		txs            map[string][][]*types.Eth1TransactionIndexed // map[chainID][block][txPosition]*types.Eth1TransactionIndexed
+		transfers      map[string][][]TransferWithIndexes
+		limit          int64
+		opts           []Option
+		addresses      []common.Address
+		expectedHashes []string
+	}{
+		{
+			name: "one sender one chain ID",
+			txs: map[string][][]*types.Eth1TransactionIndexed{
+				"1": {
+					{newTx("hash1", alice, bob, "", 0)},
+					{newTx("hash2", alice, bob, "", 1)},
+					{newTx("hash3", alice, bob, "", 2)},
+				},
+			},
+			limit:          1,
+			addresses:      []common.Address{alice},
+			expectedHashes: []string{"hash3", "hash2", "hash1"},
+		},
+		{
+			name: "two sender one chain ID",
+			txs: map[string][][]*types.Eth1TransactionIndexed{
+				"1": {
+					{newTx("hash1", alice, bob, "", 0)},
+					{newTx("hash2", carl, bob, "", 1)},
+				},
+			},
+			limit:          2,
+			addresses:      []common.Address{alice, carl},
+			expectedHashes: []string{"hash2", "hash1"},
+		},
+		{
+			name: "two sender one chain ID with limit",
+			txs: map[string][][]*types.Eth1TransactionIndexed{
+				"1": {
+					{newTx("hash1", alice, bob, "", 0)},
+					{newTx("hash2", carl, bob, "", 1)},
+					{newTx("hash3", alice, bob, "", 2)},
+					{newTx("hash4", carl, bob, "", 3)},
+				},
+			},
+			limit:          2,
+			addresses:      []common.Address{alice, carl},
+			expectedHashes: []string{"hash4", "hash3", "hash2", "hash1"},
+		},
+		{
+			name: "two sender each on one chain",
+			txs: map[string][][]*types.Eth1TransactionIndexed{
+				"1": {
+					{newTx("hash1", alice, bob, "", 0)},
+					{newTx("hash3", alice, bob, "", 2)},
+				},
+				"2": {
+					{newTx("hash2", carl, bob, "", 1)},
+					{newTx("hash4", carl, bob, "", 3)},
+				},
+			},
+			limit:          2,
+			addresses:      []common.Address{alice, carl},
+			expectedHashes: []string{"hash4", "hash3", "hash2", "hash1"},
+		},
+		{
+			name: "two sender both on two chain",
+			txs: map[string][][]*types.Eth1TransactionIndexed{
+				"1": {
+					{newTx("hash1", alice, bob, "", 0)},
+					{newTx("hash3", carl, bob, "", 2)},
+				},
+				"2": {
+					{newTx("hash2", carl, bob, "", 1)},
+					{newTx("hash4", alice, bob, "", 3)},
+				},
+			},
+			limit:          2,
+			addresses:      []common.Address{alice, carl},
+			expectedHashes: []string{"hash4", "hash3", "hash2", "hash1"},
+		},
+		{
+			name: "by method",
+			txs: map[string][][]*types.Eth1TransactionIndexed{
+				"1": {
+					{newTx("hash1", alice, bob, "foo", 0)},
+					{newTx("hash2", alice, bob, "bar", 1)},
+					{newTx("hash3", carl, bob, "foo", 2)},
+				},
+			},
+			limit:          1,
+			opts:           []Option{IgnoreTransfers(), ByMethod(hex.EncodeToString([]byte("foo")))},
+			addresses:      []common.Address{alice},
+			expectedHashes: []string{"hash1"},
+		},
+		{
+			name: "by time range",
+			txs: map[string][][]*types.Eth1TransactionIndexed{
+				"1": {
+					{newTx("hash1", alice, bob, "", 0)},
+					{newTx("hash2", alice, bob, "", 1)},
+					{newTx("hash3", alice, bob, "", 2)},
+				},
+			},
+			limit:          1,
+			opts:           []Option{WithTimeRange(timestamppb.New(t0), timestamppb.New(t0.Add(1*time.Second)))},
+			addresses:      []common.Address{alice},
+			expectedHashes: []string{"hash2", "hash1"},
+		},
+		{
+			name: "by sender",
+			txs: map[string][][]*types.Eth1TransactionIndexed{
+				"1": {
+					{newTx("hash1", alice, bob, "", 0)},
+					{newTx("hash2", bob, alice, "", 1)},
+					{newTx("hash3", alice, bob, "", 2)},
+				},
+			},
+			limit:          1,
+			opts:           []Option{OnlySent()},
+			addresses:      []common.Address{alice},
+			expectedHashes: []string{"hash3", "hash1"},
+		},
+		{
+			name: "by receiver",
+			txs: map[string][][]*types.Eth1TransactionIndexed{
+				"1": {
+					{newTx("hash1", alice, bob, "", 0)},
+					{newTx("hash2", bob, alice, "", 1)},
+					{newTx("hash3", alice, bob, "", 2)},
+				},
+			},
+			limit:          1,
+			opts:           []Option{OnlyReceived()},
+			addresses:      []common.Address{bob},
+			expectedHashes: []string{"hash3", "hash1"},
+		}, {
+			name: "only transfers",
+			txs: map[string][][]*types.Eth1TransactionIndexed{
+				"1": {
+					{newTx("hash2", alice, bob, "", 1)},
+				},
+			},
+			transfers: map[string][][]TransferWithIndexes{
+				"1": {
+					{newTransfer("hash1", alice, bob, common.Address{}, 0)},
+					{newTransfer("hash3", alice, bob, common.Address{}, 2)},
+				},
+			},
+			limit:          1,
+			opts:           []Option{IgnoreTransactions()},
+			addresses:      []common.Address{alice},
+			expectedHashes: []string{"hash3", "hash1"},
+		},
+		{
+			name: "only txs",
+			txs: map[string][][]*types.Eth1TransactionIndexed{
+				"1": {
+					{newTx("hash1", alice, bob, "", 0)},
+					{newTx("hash3", alice, bob, "", 2)},
+				},
+			},
+			transfers: map[string][][]TransferWithIndexes{
+				"1": {
+					{newTransfer("hash2", alice, bob, common.Address{}, 1)},
+				},
+			},
+			limit:          1,
+			opts:           []Option{IgnoreTransfers()},
+			addresses:      []common.Address{alice},
+			expectedHashes: []string{"hash3", "hash1"},
+		},
+		{
+			name: "mix of both",
+			txs: map[string][][]*types.Eth1TransactionIndexed{
+				"1": {
+					{newTx("hash1", alice, bob, "", 0)},
+					{newTx("hash3", alice, bob, "", 2)},
+					{newTx("hash5", alice, bob, "", 4)},
+					{newTx("hash7", alice, bob, "", 6)},
+					{newTx("hash9", alice, bob, "", 8)},
+				},
+			},
+			transfers: map[string][][]TransferWithIndexes{
+				"1": {
+					{newTransfer("hash2", alice, bob, common.Address{}, 1)},
+					{newTransfer("hash4", alice, bob, common.Address{}, 3)},
+					{newTransfer("hash6", alice, bob, common.Address{}, 5)},
+					{newTransfer("hash8", alice, bob, common.Address{}, 7)},
+					{newTransfer("hash10", alice, bob, common.Address{}, 9)},
+				},
+			},
+			limit:          2,
+			addresses:      []common.Address{alice},
+			expectedHashes: []string{"hash10", "hash9", "hash8", "hash7", "hash6", "hash5", "hash4", "hash3", "hash2", "hash1"},
+		},
+		{
+			name: "by asset with time range",
+			transfers: map[string][][]TransferWithIndexes{
+				"1": {
+					{newTransfer("hash1", alice, bob, usdc, 0)},
+					{newTransfer("hash2", alice, bob, usdc, 1)},
+					{newTransfer("hash3", alice, bob, usdc, 2)},
+					{newTransfer("hash4", alice, bob, usdc, 3)},
+					{newTransfer("hash5", alice, bob, usdc, 4)},
+				},
+			},
+			limit:          2,
+			opts:           []Option{IgnoreTransactions(), ByAsset(usdc), WithTimeRange(timestamppb.New(t0.Add(1*time.Second)), timestamppb.New(t0.Add(3*time.Second)))},
+			addresses:      []common.Address{alice},
+			expectedHashes: []string{"hash4", "hash3", "hash2"},
+		},
+		{
+			name: "by asset and sender with time range",
+			transfers: map[string][][]TransferWithIndexes{
+				"1": {
+					{newTransfer("hash1", alice, bob, usdc, 0)},
+					{newTransfer("hash2", bob, alice, usdc, 1)},
+					{newTransfer("hash3", alice, bob, usdc, 2)},
+					{newTransfer("hash4", bob, alice, usdc, 3)},
+					{newTransfer("hash5", alice, bob, usdc, 4)},
+				},
+			},
+			limit:          2,
+			opts:           []Option{IgnoreTransactions(), OnlySent(), ByAsset(usdc), WithTimeRange(timestamppb.New(t0.Add(1*time.Second)), timestamppb.New(t0.Add(3*time.Second)))},
+			addresses:      []common.Address{alice},
+			expectedHashes: []string{"hash3"},
+		},
+		{
+			name: "by asset and receiver with time range",
+			transfers: map[string][][]TransferWithIndexes{
+				"1": {
+					{newTransfer("hash1", bob, alice, usdc, 0)},
+					{newTransfer("hash2", alice, bob, usdc, 1)},
+					{newTransfer("hash3", bob, alice, usdc, 2)},
+					{newTransfer("hash4", alice, bob, usdc, 3)},
+					{newTransfer("hash5", bob, alice, usdc, 4)},
+				},
+			},
+			limit:          2,
+			opts:           []Option{IgnoreTransactions(), OnlyReceived(), ByAsset(usdc), WithTimeRange(timestamppb.New(t0.Add(1*time.Second)), timestamppb.New(t0.Add(3*time.Second)))},
+			addresses:      []common.Address{alice},
+			expectedHashes: []string{"hash3"},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			defer func() { _ = s.Clear() }()
+			for chainID, blocks := range tt.txs {
+				for _, txs := range blocks {
+					if err := store.AddBlockTransactions(chainID, txs); err != nil {
+						t.Fatal(err)
+					}
+				}
+			}
+			for chainID, blocks := range tt.transfers {
+				for _, transfers := range blocks {
+					if err := store.AddBlockERC20Transfers(chainID, transfers); err != nil {
+						t.Fatal(err)
+					}
+				}
+			}
+			chainIDs := append(maps.Keys(tt.txs), maps.Keys(tt.transfers)...)
+			sort.Strings(chainIDs)
+			chainIDs = slices.Compact(chainIDs)
+			var suffix map[string]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...)
+				if err != nil {
+					t.Fatalf("tx %d: %v", i, err)
+				}
+				if len(txs) == 0 {
+					t.Fatalf("tx %d: no transactions found", i)
+				}
+				if got, want := int64(len(txs)), tt.limit; got != want {
+					t.Errorf("got %v, want %v", got, want)
+				}
+				for j := int64(0); j < tt.limit; j++ {
+					if got, want := string(txs[j].Hash), tt.expectedHashes[i*tt.limit+j]; got != want {
+						t.Errorf("got %v, want %v", got, want)
+					}
+				}
+				suffix = newSuffix
+			}
+		})
+	}
+}
+
+var t0 = time.Date(1970, 1, 1, 0, 0, 0, 0, time.UTC)
+
+func newTx(hash string, from, to common.Address, method string, delta int64) *types.Eth1TransactionIndexed {
+	return &types.Eth1TransactionIndexed{
+		Hash:               []byte(hash),
+		BlockNumber:        0,
+		Time:               timestamppb.New(t0.Add(time.Duration(delta) * time.Second)),
+		MethodId:           []byte(method),
+		From:               from.Bytes(),
+		To:                 to.Bytes(),
+		Value:              nil,
+		TxFee:              nil,
+		GasPrice:           nil,
+		IsContractCreation: false,
+		InvokesContract:    false,
+		ErrorMsg:           "",
+		BlobTxFee:          nil,
+		BlobGasPrice:       nil,
+	}
+}
+
+func newTransfer(hash string, from, to, contract common.Address, delta int64) TransferWithIndexes {
+	return TransferWithIndexes{
+		Indexed: &types.Eth1ERC20Indexed{
+			ParentHash:   []byte(hash),
+			BlockNumber:  0,
+			TokenAddress: contract.Bytes(),
+			Time:         timestamppb.New(t0.Add(time.Duration(delta) * time.Second)),
+			From:         from.Bytes(),
+			To:           to.Bytes(),
+			Value:        nil,
+		},
+		TxIndex:  0,
+		LogIndex: 0,
+	}
+}
diff --git a/backend/pkg/commons/db2/data/filter.go b/backend/pkg/commons/db2/data/filter.go
new file mode 100644
index 000000000..aea5b19f6
--- /dev/null
+++ b/backend/pkg/commons/db2/data/filter.go
@@ -0,0 +1,250 @@
+package data
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/ethereum/go-ethereum/common"
+	"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
+	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 (c *chainFilterTx) addByAsset(common.Address) error {
+	return fmt.Errorf("cannot filter tx by asset")
+}
+
+func (c *chainFilterTx) addTimeRange(from *timestamp.Timestamp, to *timestamp.Timestamp) error {
+	if from == nil || to == nil {
+		return fmt.Errorf("invalid time range: empty border")
+	}
+	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 c.to != nil {
+		query = fmt.Sprintf("%s:%s", query, reversePaddedTimestamp(c.to))
+	}
+	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)))
+	}
+	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",
+	}
+}
+
+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()
+	}
+	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()
+	}
+	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)
+		}
+	}
+	c.asset = &asset
+	if c.filtered == byReceived {
+		return c.addByAssetReceived()
+	}
+	if c.filtered == bySent {
+		return c.addByAssetSent()
+	}
+	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 c.filtered == byReceived || c.filtered == bySent {
+		return fmt.Errorf("cannot apply range over filter by %s", c.filtered)
+	}
+	c.from = from
+	c.to = to
+	return nil
+}
+
+func (c *chainFilterTransfer) filterType() filterType {
+	return c.filtered
+}
+
+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))
+	}
+	return query
+}
+
+func (c *chainFilterTransfer) limit(prefix string) string {
+	if c.from != nil {
+		index := strings.LastIndex(prefix, ":")
+		return toSuccessor(fmt.Sprintf("%s:%s", prefix[:index], reversePaddedTimestamp(c.from)))
+	}
+	return toSuccessor(prefix)
+}
+
+// toSuccessor add suffix ";" has it comes after ":" in the ascii order
+// this is a simple way to have an infinite bound limit
+// prefix must be a real prefix and not a key
+func toSuccessor(prefix string) string {
+	return prefix + ";"
+}
diff --git a/backend/pkg/commons/db2/data/filter_test.go b/backend/pkg/commons/db2/data/filter_test.go
new file mode 100644
index 000000000..8bf258cd4
--- /dev/null
+++ b/backend/pkg/commons/db2/data/filter_test.go
@@ -0,0 +1,140 @@
+package data
+
+import (
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common"
+	"google.golang.org/protobuf/types/known/timestamppb"
+)
+
+func TestFilter(t *testing.T) {
+	tests := []struct {
+		name       string
+		filter     chainFilter
+		add        func(chainFilter) error
+		expectErr  bool
+		expectType filterType
+	}{
+		{
+			name:   "tx by asset should err",
+			filter: newChainFilterTx(),
+			add: func(c chainFilter) error {
+				return c.addByAsset(common.Address{})
+			},
+			expectErr: true,
+		},
+		{
+			name:   "tx invalid time range",
+			filter: newChainFilterTx(),
+			add: func(c chainFilter) error {
+				return c.addTimeRange(nil, nil)
+			},
+			expectErr: true,
+		},
+		{
+			name:   "transfer by method should err",
+			filter: newChainFilterTransfer(),
+			add: func(c chainFilter) error {
+				return c.addByMethod("")
+			},
+			expectErr: true,
+		},
+		{
+			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()
+			},
+			expectType: byAssetSent,
+		},
+		{
+			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()
+			},
+			expectType: byAssetReceived,
+		},
+		{
+			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{})
+			},
+			expectType: byAssetSent,
+		},
+		{
+			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{})
+			},
+			expectType: byAssetReceived,
+		},
+		{
+			name:   "transfer invalid time range",
+			filter: newChainFilterTransfer(),
+			add: func(c chainFilter) error {
+				return c.addTimeRange(nil, nil)
+			},
+			expectErr: true,
+		},
+		{
+			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()
+			},
+			expectErr: true,
+		},
+		{
+			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()
+			},
+			expectErr: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := tt.add(tt.filter)
+			if err != nil {
+				if !tt.expectErr {
+					t.Errorf("unexpected err: %s", err)
+				}
+				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)
+			}
+		})
+	}
+}
diff --git a/backend/pkg/commons/db2/data/keys.go b/backend/pkg/commons/db2/data/keys.go
new file mode 100644
index 000000000..a039db47c
--- /dev/null
+++ b/backend/pkg/commons/db2/data/keys.go
@@ -0,0 +1,228 @@
+package data
+
+import (
+	"fmt"
+	"strings"
+
+	"google.golang.org/protobuf/types/known/timestamppb"
+
+	"github.com/gobitfly/beaconchain/pkg/commons/log"
+	"github.com/gobitfly/beaconchain/pkg/commons/types"
+)
+
+const (
+	maxInt                       = 9223372036854775807
+	maxExecutionLayerBlockNumber = 1000000000
+
+	txPerBlockLimit = 10_000
+	logPerTxLimit   = 100_000
+)
+
+func reversePaddedIndex(i int, maxValue int) string {
+	if i > maxValue {
+		log.Fatal(nil, fmt.Sprintf("padded index %v is greater than the max index of %v", i, maxValue), 0)
+	}
+	// TODO probably a bug here
+	// TODO -1 means that the result will be 100, 99, 01
+	// TODO meanings index 0 (100) will be placed before index 1 (99)
+	// TODO it will be index 1 (99), ..., index 90 (10), index 0 (100), index 91 (09)
+	length := fmt.Sprintf("%d", len(fmt.Sprintf("%d", maxValue))-1)
+	fmtStr := "%0" + length + "d"
+	return fmt.Sprintf(fmtStr, maxValue-i)
+}
+
+func reversePaddedTimestamp(timestamp *timestamppb.Timestamp) string {
+	if timestamp == nil {
+		log.Fatal(nil, fmt.Sprintf("unknown timestamp: %v", timestamp), 0)
+	}
+	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)
+}
+
+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>"
+	replacer := strings.NewReplacer(
+		"<chainID>", chainID,
+		"<address>", fmt.Sprintf("%x", address),
+		"<method>", fmt.Sprintf("%x", tx.MethodId),
+		"<time>", reversePaddedTimestamp(tx.Time),
+		"<index>", reversePaddedIndex(index, txPerBlockLimit),
+	)
+	return replacer.Replace(format)
+}
+
+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)
+}
+
+func keyTxContractCreation(chainID string, tx *types.Eth1TransactionIndexed, address []byte, index int) string {
+	format := "<chainID>:I:TX:<address>:CONTRACT:<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 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),
+	)
+	return replacer.Replace(format)
+}
+
+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)
+}
diff --git a/backend/pkg/commons/db2/data/option.go b/backend/pkg/commons/db2/data/option.go
new file mode 100644
index 000000000..f28210c9b
--- /dev/null
+++ b/backend/pkg/commons/db2/data/option.go
@@ -0,0 +1,154 @@
+package data
+
+import (
+	"fmt"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/golang/protobuf/ptypes/timestamp"
+)
+
+type Option interface {
+	apply(*options)
+}
+
+type options struct {
+	from, to        *timestamp.Timestamp
+	method          *string
+	ignoreTxs       bool
+	ignoreTransfers bool
+	onlySent        bool
+	onlyReceived    bool
+	asset           *common.Address
+}
+
+func apply(opts []Option) options {
+	options := options{}
+	for _, o := range opts {
+		o.apply(&options)
+	}
+	return options
+}
+
+type byTimeRangeOption struct {
+	from *timestamp.Timestamp
+	to   *timestamp.Timestamp
+}
+
+func WithTimeRange(from *timestamp.Timestamp, to *timestamp.Timestamp) Option {
+	return byTimeRangeOption{from: from, to: to}
+}
+
+func (r byTimeRangeOption) apply(opts *options) {
+	opts.from = r.from
+	opts.to = r.to
+}
+
+type byMethodOption struct {
+	method string
+}
+
+func ByMethod(method string) Option {
+	return byMethodOption{method: method}
+}
+
+func (r byMethodOption) apply(opts *options) {
+	opts.method = &r.method
+}
+
+type ignoreTransactionsOption bool
+
+func IgnoreTransactions() Option {
+	return ignoreTransactionsOption(true)
+}
+
+func (r ignoreTransactionsOption) apply(opts *options) {
+	opts.ignoreTxs = bool(r)
+}
+
+type ignoreTransfersOption bool
+
+func IgnoreTransfers() Option {
+	return ignoreTransfersOption(true)
+}
+
+func (r ignoreTransfersOption) apply(opts *options) {
+	opts.ignoreTransfers = bool(r)
+}
+
+type onlySentOption bool
+
+func OnlySent() Option {
+	return onlySentOption(true)
+}
+
+func (r onlySentOption) apply(opts *options) {
+	opts.onlySent = bool(r)
+}
+
+type onlyReceivedOption bool
+
+func OnlyReceived() Option {
+	return onlyReceivedOption(true)
+}
+
+func (r onlyReceivedOption) apply(opts *options) {
+	opts.onlyReceived = bool(r)
+}
+
+type byAssetOption struct {
+	asset common.Address
+}
+
+func ByAsset(asset common.Address) Option {
+	return byAssetOption{asset: asset}
+}
+
+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
+	}
+
+	return f, nil
+}
diff --git a/backend/pkg/commons/db2/data/tables.go b/backend/pkg/commons/db2/data/tables.go
new file mode 100644
index 000000000..2fedb6d40
--- /dev/null
+++ b/backend/pkg/commons/db2/data/tables.go
@@ -0,0 +1,14 @@
+package data
+
+const Table = "data"
+
+var Schema = map[string][]string{
+	Table: {
+		defaultFamily,
+	},
+}
+
+const (
+	defaultFamily = "f"
+	dataColumn    = "d"
+)
diff --git a/backend/pkg/commons/db2/database/bigtable.go b/backend/pkg/commons/db2/database/bigtable.go
index a0a6b5ae2..7843410ee 100644
--- a/backend/pkg/commons/db2/database/bigtable.go
+++ b/backend/pkg/commons/db2/database/bigtable.go
@@ -17,46 +17,59 @@ const (
 	timeout = time.Minute // Timeout duration for Bigtable operations
 )
 
+type Item struct {
+	Family string
+	Column string
+	Data   []byte
+}
+
+type Row struct {
+	Key    string
+	Values map[string][]byte
+}
+
 type TableWrapper struct {
 	*BigTable
-	table  string
-	family string
+	table string
 }
 
-func Wrap(db *BigTable, table string, family string) TableWrapper {
+func Wrap(db *BigTable, table string) TableWrapper {
 	return TableWrapper{
 		BigTable: db,
 		table:    table,
-		family:   family,
 	}
 }
 
-func (w TableWrapper) Add(key, column string, data []byte, allowDuplicate bool) error {
-	return w.BigTable.Add(w.table, w.family, key, column, data, allowDuplicate)
+func (w TableWrapper) Add(key string, item Item, allowDuplicate bool) error {
+	return w.BigTable.Add(w.table, key, item, allowDuplicate)
 }
 
-func (w TableWrapper) Read(prefix string) ([][]byte, error) {
-	return w.BigTable.Read(w.table, w.family, prefix)
+func (w TableWrapper) Read(prefix string) ([]Row, error) {
+	return w.BigTable.Read(w.table, prefix)
 }
 
-func (w TableWrapper) GetLatestValue(key string) ([]byte, error) {
-	return w.BigTable.GetLatestValue(w.table, w.family, key)
+func (w TableWrapper) GetLatestValue(key string) (*Row, error) {
+	return w.BigTable.GetLatestValue(w.table, key)
 }
 
-func (w TableWrapper) GetRow(key string) (map[string][]byte, error) {
+func (w TableWrapper) GetRow(key string) (*Row, error) {
 	return w.BigTable.GetRow(w.table, key)
 }
 
-func (w TableWrapper) GetRowKeys(prefix string) ([]string, error) {
-	return w.BigTable.GetRowKeys(w.table, prefix)
+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) GetRowsRange(high, low string) ([]Row, error) {
-	return w.BigTable.GetRowsRange(w.table, high, low)
+func (w TableWrapper) GetRowsRange(high, low string, opts ...Option) ([]Row, error) {
+	return w.BigTable.GetRowsRange(w.table, high, low, opts...)
+}
+
+func (w TableWrapper) GetRowsWithKeys(keys []string) ([]Row, error) {
+	return w.BigTable.GetRowsWithKeys(w.table, keys)
 }
 
 // BigTable is a wrapper around Google Cloud Bigtable for storing and retrieving data
@@ -136,12 +149,6 @@ func createTableAndFamilies(ctx context.Context, admin *bigtable.AdminClient, ta
 	return nil
 }
 
-type Item struct {
-	Family string
-	Column string
-	Data   []byte
-}
-
 func (b BigTable) BulkAdd(table string, itemsByKey map[string][]Item) error {
 	tbl := b.client.Open(table)
 	ctx, cancel := context.WithTimeout(context.Background(), timeout)
@@ -174,7 +181,7 @@ func (b BigTable) BulkAdd(table string, itemsByKey map[string][]Item) error {
 // Add inserts a new row with the given key, column, and data into the Bigtable
 // It applies a mutation that stores data in the receiver column family
 // It returns error if the operation fails
-func (b BigTable) Add(table, family string, key string, column string, data []byte, allowDuplicate bool) error {
+func (b BigTable) Add(table, key string, item Item, allowDuplicate bool) error {
 	// Open the transfer table for data operations
 	tbl := b.client.Open(table)
 	ctx, cancel := context.WithTimeout(context.Background(), timeout)
@@ -182,7 +189,7 @@ func (b BigTable) Add(table, family string, key string, column string, data []by
 
 	// Create a new mutation to store data in the given column
 	mut := bigtable.NewMutation()
-	mut.Set(family, column, bigtable.Now(), data)
+	mut.Set(item.Family, item.Column, bigtable.Now(), item.Data)
 
 	if !allowDuplicate {
 		mut = bigtable.NewCondMutation(bigtable.RowKeyFilter(key), nil, mut)
@@ -196,37 +203,52 @@ func (b BigTable) Add(table, family string, key string, column string, data []by
 
 // Read retrieves all rows from the Bigtable's receiver column family
 // It returns the data in the form of a 2D byte slice and an error if the operation fails
-func (b BigTable) Read(table, family, prefix string) ([][]byte, error) {
+func (b BigTable) Read(table, prefix string) ([]Row, error) {
 	// Open the transfer table for reading
 	tbl := b.client.Open(table)
 	ctx, cancel := context.WithTimeout(context.Background(), timeout)
 	defer cancel()
 
-	var data [][]byte
+	var rows []Row
 	// Read all rows from the table and collect values from the receiver column family
 	err := tbl.ReadRows(ctx, bigtable.PrefixRange(prefix), func(row bigtable.Row) bool {
-		for _, item := range row[family] {
-			// Append each value from the receiver family to the data slice
-			data = append(data, item.Value)
+		values := make(map[string][]byte)
+		for _, family := range row {
+			for _, item := range family {
+				values[item.Column] = item.Value
+			}
 		}
+		rows = append(rows, Row{
+			Key:    row.Key(),
+			Values: values,
+		})
 		return true
 	})
 	if err != nil {
 		return nil, fmt.Errorf("could not read rows: %v", err)
 	}
 
-	return data, nil
+	return rows, nil
 }
 
-func (b BigTable) GetLatestValue(table, family, key string) ([]byte, error) {
+func (b BigTable) GetLatestValue(table, key string) (*Row, error) {
 	// Open the transfer table for reading
 	tbl := b.client.Open(table)
 	ctx, cancel := context.WithTimeout(context.Background(), timeout)
 	defer cancel()
 
-	var data []byte
+	var data Row
 	err := tbl.ReadRows(ctx, bigtable.PrefixRange(key), func(row bigtable.Row) bool {
-		data = row[family][0].Value
+		values := make(map[string][]byte)
+		for _, family := range row {
+			for _, item := range family {
+				values[item.Column] = item.Value
+			}
+		}
+		data = Row{
+			Key:    row.Key(),
+			Values: values,
+		}
 		return true
 	})
 
@@ -234,46 +256,51 @@ func (b BigTable) GetLatestValue(table, family, key string) ([]byte, error) {
 		return nil, fmt.Errorf("could not read rows: %v", err)
 	}
 
-	return data, nil
+	return &data, nil
 }
 
-func (b BigTable) GetRow(table, key string) (map[string][]byte, error) {
+func (b BigTable) GetRow(table, key string) (*Row, error) {
 	// Open the transfer table for reading
 	tbl := b.client.Open(table)
 	ctx, cancel := context.WithTimeout(context.Background(), timeout)
 	defer cancel()
 
-	data := make(map[string][]byte)
-	err := tbl.ReadRows(ctx, bigtable.PrefixRange(key), func(row bigtable.Row) bool {
-		for _, family := range row {
-			for _, item := range family {
-				data[item.Column] = item.Value
-			}
-		}
-		return true
-	})
-
+	var data *Row
+	row, err := tbl.ReadRow(ctx, key)
 	if err != nil {
-		return nil, fmt.Errorf("could not read rows: %v", err)
+		return nil, fmt.Errorf("could not read row: %v", err)
 	}
-	if len(data) == 0 {
+	if row == nil {
 		return nil, ErrNotFound
 	}
+	values := make(map[string][]byte)
+	for _, family := range row {
+		for _, item := range family {
+			values[item.Column] = item.Value
+		}
+	}
+	data = &Row{
+		Key:    row.Key(),
+		Values: values,
+	}
 
 	return data, nil
 }
 
-type Row struct {
-	Key    string
-	Values map[string][]byte
-}
+func (b BigTable) GetRowsRange(table, high, low string, opts ...Option) ([]Row, error) {
+	options := apply(opts)
 
-func (b BigTable) GetRowsRange(table, high, low string) ([]Row, error) {
 	tbl := b.client.Open(table)
 	ctx, cancel := context.WithTimeout(context.Background(), timeout)
 	defer cancel()
 
 	rowRange := bigtable.NewClosedRange(low, high)
+	if options.OpenRange {
+		rowRange = bigtable.NewOpenRange(low, high)
+	}
+	if options.OpenCloseRange {
+		rowRange = bigtable.NewOpenClosedRange(low, high)
+	}
 	var data []Row
 	err := tbl.ReadRows(ctx, rowRange, func(row bigtable.Row) bool {
 		values := make(map[string][]byte)
@@ -287,7 +314,7 @@ func (b BigTable) GetRowsRange(table, high, low string) ([]Row, error) {
 			Values: values,
 		})
 		return true
-	})
+	}, bigtable.LimitRows(options.Limit))
 
 	if err != nil {
 		return nil, fmt.Errorf("could not read rows: %v", err)
@@ -299,8 +326,9 @@ func (b BigTable) GetRowsRange(table, high, low string) ([]Row, error) {
 	return data, nil
 }
 
-func (b BigTable) GetRowKeys(table, prefix string) ([]string, error) {
-	// Open the transfer table for reading
+func (b BigTable) GetRowKeys(table, prefix string, opts ...Option) ([]string, error) {
+	options := apply(opts)
+
 	tbl := b.client.Open(table)
 	ctx, cancel := context.WithTimeout(context.Background(), timeout)
 	defer cancel()
@@ -310,11 +338,41 @@ func (b BigTable) GetRowKeys(table, prefix string) ([]string, error) {
 	err := tbl.ReadRows(ctx, bigtable.PrefixRange(prefix), func(row bigtable.Row) bool {
 		data = append(data, row.Key())
 		return true
+	}, bigtable.LimitRows(options.Limit))
+
+	if err != nil {
+		return nil, fmt.Errorf("could not read rows: %v", err)
+	}
+
+	return data, nil
+}
+
+func (b BigTable) GetRowsWithKeys(table string, keys []string) ([]Row, error) {
+	tbl := b.client.Open(table)
+	ctx, cancel := context.WithTimeout(context.Background(), timeout)
+	defer cancel()
+
+	var data []Row
+	err := tbl.ReadRows(ctx, bigtable.RowList(keys), func(row bigtable.Row) bool {
+		values := make(map[string][]byte)
+		for _, family := range row {
+			for _, item := range family {
+				values[item.Column] = item.Value
+			}
+		}
+		data = append(data, Row{
+			Key:    row.Key(),
+			Values: values,
+		})
+		return true
 	})
 
 	if err != nil {
 		return nil, fmt.Errorf("could not read rows: %v", err)
 	}
+	if len(data) == 0 {
+		return nil, ErrNotFound
+	}
 
 	return data, nil
 }
diff --git a/backend/pkg/commons/db2/database/bigtable_test.go b/backend/pkg/commons/db2/database/bigtable_test.go
index e7ea3b6e6..a4dde2233 100644
--- a/backend/pkg/commons/db2/database/bigtable_test.go
+++ b/backend/pkg/commons/db2/database/bigtable_test.go
@@ -1,87 +1,69 @@
 package database
 
 import (
+	"bytes"
 	"context"
+	"errors"
+	"fmt"
 	"slices"
 	"strings"
 	"testing"
 
+	"golang.org/x/exp/maps"
+
 	"github.com/gobitfly/beaconchain/pkg/commons/db2/databasetest"
 )
 
 func TestBigTable(t *testing.T) {
-	type item struct {
-		key    string
-		column string
-		data   string
-	}
 	tests := []struct {
 		name     string
 		bulk     bool
-		items    []item
+		items    map[string][]Item
 		expected []string
 	}{
 		{
 			name: "simple add",
-			items: []item{{
-				key:    "foo",
-				column: "bar",
-				data:   "foobar",
-			}},
+			items: map[string][]Item{
+				"foo": {
+					{Column: "bar", Data: []byte("foobar")},
+				},
+			},
 			expected: []string{"foobar"},
 		},
 		{
 			name: "bulk add",
 			bulk: true,
-			items: []item{{
-				key:    "key1",
-				column: "col1",
-				data:   "foobar",
-			}, {
-				key:    "key2",
-				column: "col2",
-				data:   "foobar",
-			}, {
-				key:    "key3",
-				column: "col3",
-				data:   "foobar",
-			}},
+			items: map[string][]Item{
+				"key1": {
+					{Column: "col1", Data: []byte("foobar")},
+				},
+				"key2": {
+					{Column: "col2", Data: []byte("foobar")},
+				},
+				"key3": {
+					{Column: "col3", Data: []byte("foobar")},
+				},
+			},
 			expected: []string{"foobar", "foobar", "foobar"},
 		},
-		{
-			name: "dont duplicate",
-			items: []item{{
-				key:    "foo",
-				column: "bar",
-				data:   "foobar",
-			}, {
-				key:    "foo",
-				column: "bar",
-				data:   "foobar",
-			}},
-			expected: []string{"foobar"},
-		},
 		{
 			name: "with a prefix",
-			items: []item{{
-				key: "foo",
-			}, {
-				key: "foofoo",
-			}, {
-				key: "foofoofoo",
-			}, {
-				key: "bar",
-			}},
+			items: map[string][]Item{
+				"foo":       {{}},
+				"foofoo":    {{}},
+				"foofoofoo": {{}},
+				"bar":       {{}},
+			},
 			expected: []string{"", "", "", ""},
 		},
 	}
-	tables := map[string][]string{"testTable": {"testFamily"}}
+	tables := map[string][]string{"testTable": {""}}
 	client, admin := databasetest.NewBigTable(t)
 	bt, err := NewBigTableWithClient(context.Background(), client, admin, tables)
 	if err != nil {
 		t.Fatal(err)
 	}
-	db := Wrap(bt, "testTable", "testFamily")
+	db := Wrap(bt, "testTable")
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
@@ -89,24 +71,8 @@ func TestBigTable(t *testing.T) {
 				_ = db.Clear()
 			}()
 
-			if tt.bulk {
-				itemsByKey := make(map[string][]Item)
-				for _, item := range tt.items {
-					itemsByKey[item.key] = append(itemsByKey[item.key], Item{
-						Family: "testFamily",
-						Column: item.column,
-						Data:   []byte(item.data),
-					})
-				}
-				if err := db.BulkAdd(itemsByKey); err != nil {
-					t.Error(err)
-				}
-			} else {
-				for _, it := range tt.items {
-					if err := db.Add(it.key, it.column, []byte(it.data), false); err != nil {
-						t.Error(err)
-					}
-				}
+			if err := db.BulkAdd(tt.items); err != nil {
+				t.Error(err)
 			}
 
 			t.Run("Read", func(t *testing.T) {
@@ -117,44 +83,48 @@ func TestBigTable(t *testing.T) {
 				if got, want := len(res), len(tt.expected); got != want {
 					t.Errorf("got %v want %v", got, want)
 				}
-				for _, data := range res {
-					if !slices.Contains(tt.expected, string(data)) {
-						t.Errorf("wrong data %s", data)
+				for _, row := range res {
+					for _, v := range row.Values {
+						if !slices.Contains(tt.expected, string(v)) {
+							t.Errorf("wrong data %s", row)
+						}
 					}
 				}
 			})
 
 			t.Run("GetLatestValue", func(t *testing.T) {
-				for _, it := range tt.items {
-					v, err := db.GetLatestValue(it.key)
+				for key, items := range tt.items {
+					v, err := db.GetLatestValue(key)
 					if err != nil {
 						t.Error(err)
 					}
-					if got, want := string(v), it.data; got != want {
-						t.Errorf("got %v want %v", got, want)
+					for _, it := range items {
+						if got, want := string(v.Values[fmt.Sprintf("%s:%s", it.Family, it.Column)]), string(it.Data); got != want {
+							t.Errorf("got %v want %v", got, want)
+						}
 					}
 				}
 			})
 
 			t.Run("GetRowKeys", func(t *testing.T) {
-				for _, it := range tt.items {
-					keys, err := db.GetRowKeys(it.key)
+				for key := range tt.items {
+					keys, err := db.GetRowKeys(key)
 					if err != nil {
 						t.Error(err)
 					}
 					count, found := 0, false
-					for _, expected := range tt.items {
-						if !strings.HasPrefix(expected.key, it.key) {
+					for expectedKey := range tt.items {
+						if !strings.HasPrefix(expectedKey, key) {
 							continue
 						}
 						// don't count duplicate inputs since the add prevent duplicate keys
-						if expected.key == it.key && found {
+						if expectedKey == key && found {
 							continue
 						}
-						found = expected.key == it.key
+						found = expectedKey == key
 						count++
-						if !slices.Contains(keys, expected.key) {
-							t.Errorf("missing %v in %v", expected.key, keys)
+						if !slices.Contains(keys, expectedKey) {
+							t.Errorf("missing %v in %v", expectedKey, keys)
 						}
 					}
 					if got, want := len(keys), count; got != want {
@@ -162,6 +132,44 @@ func TestBigTable(t *testing.T) {
 					}
 				}
 			})
+
+			t.Run("GetRow", func(t *testing.T) {
+				for key, items := range tt.items {
+					row, err := db.GetRow(key)
+					if err != nil {
+						t.Error(err)
+					}
+					if got, want := row.Key, key; got != want {
+						t.Errorf("got %v want %v", got, want)
+					}
+					for _, it := range items {
+						if got, want := string(row.Values[fmt.Sprintf("%s:%s", it.Family, it.Column)]), string(it.Data); got != want {
+							t.Errorf("got %v want %v", got, want)
+						}
+					}
+				}
+				_, err := db.GetRow("key does not exist")
+				if !errors.Is(err, ErrNotFound) {
+					t.Errorf("expected ErrNotFound got %v", err)
+				}
+			})
+
+			t.Run("GetRowsWithKeys", func(t *testing.T) {
+				rows, err := db.GetRowsWithKeys(maps.Keys(tt.items))
+				if err != nil {
+					t.Error(err)
+				}
+				for _, row := range rows {
+					expected := make(map[string][]byte)
+					for i := 0; i < len(tt.items[row.Key]); i++ {
+						it := tt.items[row.Key][i]
+						expected[fmt.Sprintf("%s:%s", it.Family, it.Column)] = it.Data
+					}
+					if got, want := row.Values, expected; !maps.EqualFunc(got, want, func(b1 []byte, b2 []byte) bool { return bytes.Equal(b1, b2) }) {
+						t.Errorf("got %v want %v", got, want)
+					}
+				}
+			})
 		})
 	}
 
@@ -170,23 +178,65 @@ func TestBigTable(t *testing.T) {
 	}
 }
 
-func TestRangeIncludeLimits(t *testing.T) {
-	tables := map[string][]string{"testTable": {"testFamily"}}
+func TestGetRowsRange(t *testing.T) {
+	tables := map[string][]string{"testTable": {""}}
 	client, admin := databasetest.NewBigTable(t)
 	bt, err := NewBigTableWithClient(context.Background(), client, admin, tables)
 	if err != nil {
 		t.Fatal(err)
 	}
-	db := Wrap(bt, "testTable", "testFamily")
-
-	_ = db.Add("1:999999999999", "", []byte("0"), false)
-	_ = db.Add("1:999999999998", "", []byte("1"), false)
+	db := Wrap(bt, "testTable")
 
-	rows, err := db.GetRowsRange("1:999999999999", "1:999999999998")
-	if err != nil {
-		t.Fatal(err)
+	tests := []struct {
+		name     string
+		txs      int // must be inferior or equal to 10, otherwise padding is necessary
+		expected int
+		options  []Option
+	}{
+		{
+			name:     "closed range",
+			txs:      3,
+			expected: 3,
+		},
+		{
+			name:     "open range",
+			txs:      3,
+			expected: 1,
+			options:  []Option{WithOpenRange(true)},
+		},
+		{
+			name:     "open close range",
+			txs:      3,
+			expected: 2,
+			options:  []Option{WithOpenCloseRange(true)},
+		},
+		{
+			name:     "with limit",
+			txs:      9,
+			expected: 5,
+			options:  []Option{WithLimit(5)},
+		},
 	}
-	if got, want := len(rows), 2; got != want {
-		t.Errorf("got %v want %v", got, want)
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			high, low := "", ""
+			for i := 0; i < tt.txs; i++ {
+				key := fmt.Sprintf("%d", 9-i)
+				if i == 0 {
+					high = key
+				}
+				if i == tt.txs-1 {
+					low = key
+				}
+				_ = db.Add(key, Item{}, false)
+			}
+			rows, err := db.GetRowsRange(high, low, tt.options...)
+			if err != nil {
+				t.Error(err)
+			}
+			if got, want := len(rows), tt.expected; got != want {
+				t.Errorf("got %v want %v", got, want)
+			}
+		})
 	}
 }
diff --git a/backend/pkg/commons/db2/database/option.go b/backend/pkg/commons/db2/database/option.go
new file mode 100644
index 000000000..58d352a49
--- /dev/null
+++ b/backend/pkg/commons/db2/database/option.go
@@ -0,0 +1,49 @@
+package database
+
+type options struct {
+	OpenRange      bool
+	OpenCloseRange bool
+	Limit          int64
+}
+
+func apply(opts []Option) options {
+	options := options{}
+	for _, o := range opts {
+		o.apply(&options)
+	}
+	return options
+}
+
+type Option interface {
+	apply(*options)
+}
+
+type openRangeOption bool
+
+func (r openRangeOption) apply(opts *options) {
+	opts.OpenRange = bool(r)
+}
+
+func WithOpenRange(r bool) Option {
+	return openRangeOption(r)
+}
+
+type openCloseRangeOption bool
+
+func (r openCloseRangeOption) apply(opts *options) {
+	opts.OpenCloseRange = bool(r)
+}
+
+func WithOpenCloseRange(r bool) Option {
+	return openCloseRangeOption(r)
+}
+
+type limitOption int64
+
+func (l limitOption) apply(opts *options) {
+	opts.Limit = int64(l)
+}
+
+func WithLimit(l int64) Option {
+	return limitOption(l)
+}
diff --git a/backend/pkg/commons/db2/database/remote.go b/backend/pkg/commons/db2/database/remote.go
index 6d298bd57..d201134c1 100644
--- a/backend/pkg/commons/db2/database/remote.go
+++ b/backend/pkg/commons/db2/database/remote.go
@@ -9,8 +9,10 @@ import (
 )
 
 const (
-	routeGetRowsRange = "/rowRange"
-	routeGetRow       = "/row"
+	routeGetRowsRange    = "/rowRange"
+	routeGetRow          = "/row"
+	routeRead            = "/read"
+	routeGetRowsWithKeys = "/rowsWithKeys"
 )
 
 type RemoteServer struct {
@@ -25,36 +27,31 @@ func (api RemoteServer) Routes() http.Handler {
 	mux := http.NewServeMux()
 	mux.HandleFunc(routeGetRowsRange, api.GetRowsRange)
 	mux.HandleFunc(routeGetRow, api.GetRow)
+	mux.HandleFunc(routeRead, api.Read)
+	mux.HandleFunc(routeGetRowsWithKeys, api.GetRowsWithKeys)
 
 	return mux
 }
 
 type ParamsGetRowsRange struct {
-	High string `json:"high"`
-	Low  string `json:"low"`
+	High      string `json:"high"`
+	Low       string `json:"low"`
+	Limit     int64  `json:"limit"`
+	OpenRange bool   `json:"open_range"`
 }
 
 func (api RemoteServer) GetRowsRange(w http.ResponseWriter, r *http.Request) {
 	var args ParamsGetRowsRange
-	err := json.NewDecoder(r.Body).Decode(&args)
-	if err != nil {
-		w.WriteHeader(http.StatusBadRequest)
-		_, _ = w.Write([]byte(err.Error()))
-		return
-	}
-	rows, err := api.db.GetRowsRange(args.High, args.Low)
-	if err != nil {
-		w.WriteHeader(http.StatusInternalServerError)
-		_, _ = w.Write([]byte(err.Error()))
+	if err := json.NewDecoder(r.Body).Decode(&args); err != nil {
+		respondWithErr(w, http.StatusBadRequest, err)
 		return
 	}
-	data, err := json.Marshal(rows)
+	rows, err := api.db.GetRowsRange(args.High, args.Low, WithOpenRange(args.OpenRange), WithLimit(args.Limit))
 	if err != nil {
-		w.WriteHeader(http.StatusInternalServerError)
-		_, _ = w.Write([]byte(err.Error()))
+		respondWithErr(w, http.StatusInternalServerError, err)
 		return
 	}
-	_, _ = w.Write(data)
+	respond(w, rows)
 }
 
 type ParamsGetRow struct {
@@ -63,25 +60,67 @@ type ParamsGetRow struct {
 
 func (api RemoteServer) GetRow(w http.ResponseWriter, r *http.Request) {
 	var args ParamsGetRow
-	err := json.NewDecoder(r.Body).Decode(&args)
-	if err != nil {
-		w.WriteHeader(http.StatusBadRequest)
-		_, _ = w.Write([]byte(err.Error()))
+	if err := json.NewDecoder(r.Body).Decode(&args); err != nil {
+		respondWithErr(w, http.StatusBadRequest, err)
 		return
 	}
 	row, err := api.db.GetRow(args.Key)
 	if err != nil {
-		w.WriteHeader(http.StatusInternalServerError)
-		_, _ = w.Write([]byte(err.Error()))
+		respondWithErr(w, http.StatusInternalServerError, err)
+		return
+	}
+	respond(w, row)
+}
+
+type ParamsRead struct {
+	Prefix string `json:"prefix"`
+}
+
+func (api RemoteServer) Read(w http.ResponseWriter, r *http.Request) {
+	var args ParamsRead
+	if err := json.NewDecoder(r.Body).Decode(&args); err != nil {
+		respondWithErr(w, http.StatusBadRequest, err)
+		return
+	}
+	rows, err := api.db.Read(args.Prefix)
+	if err != nil {
+		respondWithErr(w, http.StatusInternalServerError, err)
+		return
+	}
+	respond(w, rows)
+}
+
+type ParamsGetRowsWithKeys struct {
+	Keys []string `json:"keys"`
+}
+
+func (api RemoteServer) GetRowsWithKeys(w http.ResponseWriter, r *http.Request) {
+	var args ParamsGetRowsWithKeys
+	if err := json.NewDecoder(r.Body).Decode(&args); err != nil {
+		respondWithErr(w, http.StatusBadRequest, err)
+		return
+	}
+	rows, err := api.db.GetRowsWithKeys(args.Keys)
+	if err != nil {
+		respondWithErr(w, http.StatusInternalServerError, err)
 		return
 	}
-	data, err := json.Marshal(row)
+	respond(w, rows)
+}
+
+func respond(w http.ResponseWriter, data any) {
+	b, err := json.Marshal(data)
 	if err != nil {
 		w.WriteHeader(http.StatusInternalServerError)
 		_, _ = w.Write([]byte(err.Error()))
 		return
 	}
-	_, _ = w.Write(data)
+	_, _ = w.Write(b)
+}
+
+func respondWithErr(w http.ResponseWriter, statusCode int, err error) {
+	w.WriteHeader(statusCode)
+	_, _ = w.Write([]byte(err.Error()))
 }
 
 type RemoteClient struct {
@@ -92,7 +131,7 @@ func NewRemoteClient(url string) *RemoteClient {
 	return &RemoteClient{url: url}
 }
 
-func (r RemoteClient) Add(key, column string, data []byte, allowDuplicate bool) error {
+func (r RemoteClient) Add(key string, item Item, allowDuplicate bool) error {
 	//TODO implement me
 	panic("implement me")
 }
@@ -102,12 +141,32 @@ func (r RemoteClient) BulkAdd(itemsByKey map[string][]Item) error {
 	panic("implement me")
 }
 
-func (r RemoteClient) Read(prefix string) ([][]byte, error) {
-	//TODO implement me
-	panic("implement me")
+func (r RemoteClient) Read(prefix string) ([]Row, error) {
+	b, err := json.Marshal(ParamsRead{Prefix: prefix})
+	if err != nil {
+		return nil, err
+	}
+	req, err := http.NewRequest(http.MethodPost, fmt.Sprintf("%s%s", r.url, routeRead), bytes.NewReader(b))
+	if err != nil {
+		return nil, err
+	}
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		b, _ := io.ReadAll(resp.Body)
+		return nil, fmt.Errorf("unexpected status code %d: %s", resp.StatusCode, b)
+	}
+	var rows []Row
+	if err := json.NewDecoder(resp.Body).Decode(&rows); err != nil {
+		return nil, err
+	}
+	return rows, nil
 }
 
-func (r RemoteClient) GetRow(key string) (map[string][]byte, error) {
+func (r RemoteClient) GetRow(key string) (*Row, error) {
 	b, err := json.Marshal(ParamsGetRow{Key: key})
 	if err != nil {
 		return nil, err
@@ -123,29 +182,35 @@ func (r RemoteClient) GetRow(key string) (map[string][]byte, error) {
 	defer resp.Body.Close()
 	if resp.StatusCode != http.StatusOK {
 		b, _ := io.ReadAll(resp.Body)
+		if ErrNotFound.Error() == string(b) {
+			return nil, ErrNotFound
+		}
 		return nil, fmt.Errorf("unexpected status code %d: %s", resp.StatusCode, b)
 	}
-	var row map[string][]byte
+	var row Row
 	if err := json.NewDecoder(resp.Body).Decode(&row); err != nil {
 		return nil, err
 	}
-	return row, nil
+	return &row, nil
 }
 
-func (r RemoteClient) GetRowKeys(prefix string) ([]string, error) {
+func (r RemoteClient) GetRowKeys(prefix string, opts ...Option) ([]string, error) {
 	//TODO implement me
 	panic("implement me")
 }
 
-func (r RemoteClient) GetLatestValue(key string) ([]byte, error) {
+func (r RemoteClient) GetLatestValue(key string) (*Row, error) {
 	//TODO implement me
 	panic("implement me")
 }
 
-func (r RemoteClient) GetRowsRange(high, low string) ([]Row, error) {
+func (r RemoteClient) GetRowsRange(high, low string, opts ...Option) ([]Row, error) {
+	options := apply(opts)
 	b, err := json.Marshal(ParamsGetRowsRange{
-		High: high,
-		Low:  low,
+		High:      high,
+		Low:       low,
+		Limit:     options.Limit,
+		OpenRange: options.OpenRange,
 	})
 	if err != nil {
 		return nil, err
@@ -159,6 +224,36 @@ func (r RemoteClient) GetRowsRange(high, low string) ([]Row, error) {
 		return nil, err
 	}
 	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		b, _ := io.ReadAll(resp.Body)
+		if ErrNotFound.Error() == string(b) {
+			return nil, ErrNotFound
+		}
+		return nil, fmt.Errorf("unexpected status code %d: %s", resp.StatusCode, b)
+	}
+	var rows []Row
+	if err := json.NewDecoder(resp.Body).Decode(&rows); err != nil {
+		return nil, err
+	}
+	return rows, nil
+}
+
+func (r RemoteClient) GetRowsWithKeys(keys []string) ([]Row, error) {
+	b, err := json.Marshal(ParamsGetRowsWithKeys{
+		Keys: keys,
+	})
+	if err != nil {
+		return nil, err
+	}
+	req, err := http.NewRequest(http.MethodPost, fmt.Sprintf("%s%s", r.url, routeGetRowsWithKeys), bytes.NewReader(b))
+	if err != nil {
+		return nil, err
+	}
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
 	if resp.StatusCode != http.StatusOK {
 		b, _ := io.ReadAll(resp.Body)
 		return nil, fmt.Errorf("unexpected status code %d: %s", resp.StatusCode, b)
diff --git a/backend/pkg/commons/db2/database/remote_test.go b/backend/pkg/commons/db2/database/remote_test.go
new file mode 100644
index 000000000..70be44392
--- /dev/null
+++ b/backend/pkg/commons/db2/database/remote_test.go
@@ -0,0 +1,84 @@
+package database
+
+import (
+	"context"
+	"errors"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/gobitfly/beaconchain/pkg/commons/db2/databasetest"
+)
+
+func TestRemote(t *testing.T) {
+	tables := map[string][]string{"testTable": {""}}
+	btClient, admin := databasetest.NewBigTable(t)
+	bt, err := NewBigTableWithClient(context.Background(), btClient, admin, tables)
+	if err != nil {
+		t.Fatal(err)
+	}
+	db := Wrap(bt, "testTable")
+
+	remote := NewRemote(db)
+	server := httptest.NewServer(remote.Routes())
+	defer server.Close()
+
+	client := NewRemoteClient(server.URL)
+
+	items := map[string]Item{
+		"foo": {},
+		"bar": {},
+	}
+	for key, item := range items {
+		if err := db.Add(key, item, false); err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	t.Run("Read", func(t *testing.T) {
+		res, err := client.Read("")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if got, want := len(res), len(items); got != want {
+			t.Fatalf("got %v, want %v", got, want)
+		}
+	})
+
+	t.Run("GetRow", func(t *testing.T) {
+		row, err := client.GetRow("foo")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if row == nil {
+			t.Fatal("row is nil")
+		}
+
+		if _, err := client.GetRow("key does not exist"); !errors.Is(err, ErrNotFound) {
+			t.Errorf("expected ErrNotFound got %v", err)
+		}
+	})
+
+	t.Run("GetRowsRange", func(t *testing.T) {
+		rows, err := client.GetRowsRange("foo", "bar")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if rows == nil {
+			t.Fatal("rows is nil")
+		}
+
+		if _, err := client.GetRowsRange("0", "1"); !errors.Is(err, ErrNotFound) {
+			t.Errorf("expected ErrNotFound got %v", err)
+		}
+	})
+
+	t.Run("GetRowsWithKeys", func(t *testing.T) {
+		rows, err := client.GetRowsWithKeys([]string{"foo", "bar"})
+		if err != nil {
+			t.Fatal(err)
+		}
+		if rows == nil {
+			t.Fatal("rows is nil")
+		}
+	})
+}
diff --git a/backend/pkg/commons/db2/database/store.go b/backend/pkg/commons/db2/database/store.go
index 3b5d15faa..5e782362f 100644
--- a/backend/pkg/commons/db2/database/store.go
+++ b/backend/pkg/commons/db2/database/store.go
@@ -1,13 +1,15 @@
 package database
 
 type Database interface {
-	Add(key, column string, data []byte, allowDuplicate bool) error
+	Add(key string, item Item, allowDuplicate bool) error
 	BulkAdd(itemsByKey map[string][]Item) error
-	Read(prefix string) ([][]byte, error)
-	GetRow(key string) (map[string][]byte, error)
-	GetRowKeys(prefix string) ([]string, error)
-	GetLatestValue(key string) ([]byte, error)
-	GetRowsRange(high, low string) ([]Row, error)
+	Read(prefix string) ([]Row, error)
+	GetRow(key string) (*Row, error)
+	GetRowsWithKeys(keys []string) ([]Row, error)
+	GetRowKeys(prefix string, opts ...Option) ([]string, error)
+	GetLatestValue(key string) (*Row, error)
+	GetRowsRange(high, low string, opts ...Option) ([]Row, error)
+
 	Close() error
 	Clear() error
 }
diff --git a/backend/pkg/commons/db2/databasetest/bigtable.go b/backend/pkg/commons/db2/databasetest/bigtable.go
index 89b92cf52..d734df661 100644
--- a/backend/pkg/commons/db2/databasetest/bigtable.go
+++ b/backend/pkg/commons/db2/databasetest/bigtable.go
@@ -12,6 +12,7 @@ import (
 )
 
 func NewBigTable(t testing.TB) (*bigtable.Client, *bigtable.AdminClient) {
+	t.Helper()
 	srv, err := bttest.NewServer("localhost:0")
 	if err != nil {
 		t.Fatal(err)
diff --git a/backend/pkg/commons/db2/raw/client_test.go b/backend/pkg/commons/db2/raw/client_test.go
index 9004b081f..ab82479d9 100644
--- a/backend/pkg/commons/db2/raw/client_test.go
+++ b/backend/pkg/commons/db2/raw/client_test.go
@@ -43,12 +43,12 @@ func TestBigTableClientRealCondition(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			bg, err := database.NewBigTable(project, instance, nil)
+			bt, err := database.NewBigTable(project, instance, nil)
 			if err != nil {
 				t.Fatal(err)
 			}
 
-			rawStore := NewStore(database.Wrap(bg, BlocksRawTable, ""))
+			rawStore := NewStore(database.Wrap(bt, BlocksRawTable))
 			rpcClient, err := rpc.DialOptions(context.Background(), "http://foo.bar", rpc.WithHTTPClient(&http.Client{
 				Transport: NewBigTableEthRaw(rawStore, chainID),
 			}))
@@ -130,7 +130,7 @@ func BenchmarkRawBigTable(b *testing.B) {
 		b.Fatal(err)
 	}
 
-	rawStore := WithCache(NewStore(database.Wrap(bt, BlocksRawTable, "")))
+	rawStore := WithCache(NewStore(database.Wrap(bt, BlocksRawTable)))
 	rpcClient, err := rpc.DialOptions(context.Background(), "http://foo.bar", rpc.WithHTTPClient(&http.Client{
 		Transport: NewBigTableEthRaw(rawStore, chainID),
 	}))
@@ -166,14 +166,14 @@ func TestBigTableClient(t *testing.T) {
 	}
 
 	client, admin := databasetest.NewBigTable(t)
-	bg, err := database.NewBigTableWithClient(context.Background(), client, admin, Schema)
+	bt, err := database.NewBigTableWithClient(context.Background(), client, admin, Schema)
 	if err != nil {
 		t.Fatal(err)
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			rawStore := NewStore(database.Wrap(bg, BlocksRawTable, ""))
+			rawStore := NewStore(database.Wrap(bt, BlocksRawTable))
 			if err := rawStore.AddBlocks([]FullBlockData{tt.block}); err != nil {
 				t.Fatal(err)
 			}
@@ -237,7 +237,7 @@ func TestBigTableClientWithFallback(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			rawStore := NewStore(database.Wrap(bt, BlocksRawTable, ""))
+			rawStore := NewStore(database.Wrap(bt, BlocksRawTable))
 
 			rpcClient, err := rpc.DialOptions(context.Background(), node, rpc.WithHTTPClient(&http.Client{
 				Transport: NewWithFallback(NewBigTableEthRaw(rawStore, tt.block.ChainID), http.DefaultTransport),
diff --git a/backend/pkg/commons/db2/raw/raw.go b/backend/pkg/commons/db2/raw/raw.go
index 45b2008c8..a6c4a0ef0 100644
--- a/backend/pkg/commons/db2/raw/raw.go
+++ b/backend/pkg/commons/db2/raw/raw.go
@@ -94,11 +94,11 @@ func (store Store) ReadBlockByHash(chainID uint64, hash string) (*FullBlockData,
 
 func (store Store) readBlock(chainID uint64, number int64) (*FullBlockData, error) {
 	key := blockKey(chainID, number)
-	data, err := store.db.GetRow(key)
+	row, err := store.db.GetRow(key)
 	if err != nil {
 		return nil, err
 	}
-	return store.parseRow(chainID, number, data)
+	return store.parseRow(chainID, number, row.Values)
 }
 
 func (store Store) parseRow(chainID uint64, number int64, data map[string][]byte) (*FullBlockData, error) {
diff --git a/backend/pkg/commons/db2/raw/raw_test.go b/backend/pkg/commons/db2/raw/raw_test.go
index 06354a1e9..44216f090 100644
--- a/backend/pkg/commons/db2/raw/raw_test.go
+++ b/backend/pkg/commons/db2/raw/raw_test.go
@@ -19,7 +19,7 @@ func TestRaw(t *testing.T) {
 	}
 
 	store := Store{
-		db:         database.Wrap(s, BlocksRawTable, ""),
+		db:         database.Wrap(s, BlocksRawTable),
 		compressor: noOpCompressor{},
 	}
 
diff --git a/backend/pkg/commons/db2/rawtest/raw.go b/backend/pkg/commons/db2/rawtest/raw.go
index 487e48096..ab633e69e 100644
--- a/backend/pkg/commons/db2/rawtest/raw.go
+++ b/backend/pkg/commons/db2/rawtest/raw.go
@@ -15,13 +15,14 @@ import (
 )
 
 func NewRandSeededStore(t *testing.T) (raw.Store, *th.BlockchainBackend) {
+	t.Helper()
 	client, admin := databasetest.NewBigTable(t)
 	bt, err := database.NewBigTableWithClient(context.Background(), client, admin, raw.Schema)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	db := raw.NewStore(database.Wrap(bt, raw.BlocksRawTable, ""))
+	db := raw.NewStore(database.Wrap(bt, raw.BlocksRawTable))
 
 	backend := th.NewBackend(t)
 	for i := 0; i < 10; i++ {