feat: added account indexer

Makefile

@@ -164,6 +164,13 @@ else
  go build -mod=readonly $(BUILD_FLAGS) -o $(BUILDDIR)/feather-core ./cmd/feather-core
 endif
 
+build-mantlemint: go.sum
+ifeq ($(OS),Windows_NT)
+ exit 1
+else
+ go build -mod=readonly $(BUILD_FLAGS) -o $(BUILDDIR)/mantlemint ./mantlemint/sync.go
+endif
+
 build-contract-tests-hooks:
 ifeq ($(OS),Windows_NT)
  go build -mod=readonly $(BUILD_FLAGS) -o $(BUILDDIR)/contract_tests.exe ./cmd/contract_tests

mantlemint/config/config.go

@@ -4,10 +4,8 @@ import (
  "fmt"
  "os"
  "path/filepath"
- "strconv"
  "strings"
 
- sdk "github.com/cosmos/cosmos-sdk/types"
  "github.com/cosmos/cosmos-sdk/x/crisis"
  "github.com/spf13/pflag"
  "github.com/spf13/viper"
@@ -24,8 +22,6 @@ type Config struct {
  IndexerDB string
  DisableSync bool
  EnableExportModule bool
- RichlistLength int
- RichlistThreshold *sdk.Coin
 }
 
 var singleton Config
@@ -86,35 +82,6 @@ func newConfig() Config {
  enableExport := getValidEnv("ENABLE_EXPORT_MODULE")
  return enableExport == "true"
  }(),
-
- // RichlistLength have to be greater than or equal to 0, richlist function will be off if length is 0
- RichlistLength: func() int {
- lengthStr := getValidEnv("RICHLIST_LENGTH")
- length, err := strconv.Atoi(lengthStr)
- if err != nil {
- panic(err)
- }
- if length < 0 {
- panic(fmt.Errorf("RICHLIST_LENGTH(%s) is invalid", lengthStr))
- }
- return length
- }(),
-
- // RichlistThreshold (format: {amount}{denom} like 1000000000000uluna)
- RichlistThreshold: func() *sdk.Coin {
- // don't need to read threshold env if the length of richlist is 0
- lengthStr := getValidEnv("RICHLIST_LENGTH")
- length, _ := strconv.Atoi(lengthStr)
- if length == 0 {
- return nil
- }
-
- thresholdCoin, err := sdk.ParseCoinNormalized(getValidEnv("RICHLIST_THRESHOLD"))
- if err != nil {
- panic(fmt.Errorf("RICHLIST_THRESHOLD is invalid: %v", err))
- }
- return &thresholdCoin
- }(),
  }
 
  viper.SetConfigType("toml")

mantlemint/indexer/accounttx/accounttx.go

@@ -0,0 +1,210 @@
+package accounttx
+
+import (
+ "encoding/json"
+ "fmt"
+ tmdb "github.com/cometbft/cometbft-db"
+ abci "github.com/cometbft/cometbft/abci/types"
+ tmjson "github.com/cometbft/cometbft/libs/json"
+ tm "github.com/cometbft/cometbft/types"
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ terra "github.com/terra-money/alliance/app"
+ "github.com/terra-money/feather-core/app"
+
+ "github.com/terra-money/feather-core/mantlemint/db/safe_batch"
+ "github.com/terra-money/feather-core/mantlemint/indexer"
+ "github.com/terra-money/feather-core/mantlemint/indexer/tx"
+ "github.com/terra-money/feather-core/mantlemint/mantlemint"
+)
+
+var cdc = app.MakeEncodingConfig()
+
+var IndexTx = indexer.CreateIndexer(func(db safe_batch.SafeBatchDB, block *tm.Block, blockID *tm.BlockID, evc *mantlemint.EventCollector, _ *app.App) error {
+ for i, txByte := range block.Txs {
+ txRecord := evc.ResponseDeliverTxs[i]
+ addrsInTx, err := parseTxBytesForAddresses(txByte)
+ if err != nil {
+ return err
+ }
+ addrsInEvents, err := parseEventsForAddresses(txRecord.Events)
+ if err != nil {
+ return err
+ }
+
+ for k, _ := range addrsInEvents {
+ addrsInTx[k] = true
+ }
+
+ for addr, _ := range addrsInTx {
+ key := GetAccountTxKey(addr, uint64(block.Height), uint64(i))
+ accountTx := AccountTx{
+ TxHash: fmt.Sprintf("%X", txByte.Hash()),
+ BlockHeight: uint64(block.Height),
+ Timestamp: block.Time,
+ }
+ b, err := json.Marshal(accountTx)
+ if err != nil {
+ return err
+ }
+ err = db.Set(key, b)
+ if err != nil {
+ return err
+ }
+ }
+ }
+ return nil
+})
+
+func parseTxBytesForAddresses(txByte []byte) (addrs map[string]bool, err error) {
+ // Use a map to collect unique addresses
+ addrs = make(map[string]bool)
+
+ // Decode to Tx struct
+ tx, err := cdc.TxConfig.TxDecoder()(txByte)
+ if err != nil {
+ return addrs, err
+ }
+
+ wrappedTx, err := cdc.TxConfig.WrapTxBuilder(tx)
+ if err != nil {
+ return addrs, err
+ }
+
+ signers := wrappedTx.GetTx().GetSigners()
+ for _, signer := range signers {
+ addr, err := sdk.Bech32ifyAddressBytes(terra.AccountAddressPrefix, signer)
+ if err != nil {
+ return addrs, err
+ }
+ addrs[addr] = true
+ }
+
+ // Encode to JSON
+ jsonByte, err := cdc.TxConfig.TxJSONEncoder()(tx)
+ if err != nil {
+ return addrs, err
+ }
+ // Decode to generic interface to find addresses
+ var txRaw map[string]interface{}
+ err = json.Unmarshal(jsonByte, &txRaw)
+ if err != nil {
+ return addrs, err
+ }
+ bodyRaw, found := txRaw["body"]
+ if !found {
+ return addrs, nil
+ }
+
+ body, ok := bodyRaw.(map[string]interface{})
+ if !ok {
+ return addrs, fmt.Errorf("unable to coerce tx body into map")
+ }
+
+ var findAddresses func(o interface{})
+ findAddresses = func(o interface{}) {
+ stringValue, isString := o.(string)
+ if isString {
+ _, err := sdk.GetFromBech32(stringValue, terra.AccountAddressPrefix)
+ if err == nil {
+ addrs[stringValue] = true
+ }
+ return
+ }
+
+ mapValue, isMap := o.(map[string]interface{})
+ if isMap {
+ for _, v := range mapValue {
+ findAddresses(v)
+ }
+ return
+ }
+
+ arrayValue, isArray := o.([]interface{})
+ if isArray {
+ for _, a := range arrayValue {
+ findAddresses(a)
+ }
+ }
+ }
+
+ msgsRaw, found := body["messages"]
+ if !found {
+ return addrs, nil
+ }
+ findAddresses(msgsRaw)
+ return addrs, nil
+}
+
+func parseEventsForAddresses(events []abci.Event) (addrs map[string]bool, err error) {
+ addrs = make(map[string]bool)
+ for _, event := range events {
+ attrs := event.GetAttributes()
+ for _, attr := range attrs {
+ addrStr := string(attr.GetValue())
+ _, err := sdk.GetFromBech32(addrStr, terra.AccountAddressPrefix)
+ if err == nil {
+ addrs[addrStr] = true
+ }
+ }
+ }
+ return addrs, nil
+}
+
+func getTxnsByAccount(db tmdb.DB, account string, offset uint64, limit uint64) (txs []tx.TxByHeightRecord, err error) {
+ key := GetAccountTxKeyByAddr(account)
+ iter, err := db.Iterator(key, sdk.PrefixEndBytes(key))
+ if err != nil {
+ return txs, err
+ }
+ currentOffset := uint64(0)
+ currentLimit := uint64(0)
+ for iter.Valid() {
+ if currentOffset < offset {
+ currentOffset += 1
+ continue
+ }
+ var accountTx AccountTx
+ b := iter.Value()
+ err = json.Unmarshal(b, &accountTx)
+ if err != nil {
+ return txs, err
+ }
+ txRecord, err := tx.GetTxByHash(db, accountTx.TxHash)
+ if err != nil {
+ return txs, err
+ }
+
+ var txResponse tx.ResponseDeliverTx
+ err = tmjson.Unmarshal(txRecord.TxResponse, &txResponse)
+ if err != nil {
+ return txs, err
+ }
+ txRes := tx.TxByHeightRecord{
+ Code: txResponse.Code,
+ Codespace: txResponse.Codespace,
+ GasUsed: txResponse.GasUsed,
+ GasWanted: txResponse.GasWanted,
+ Height: int64(accountTx.BlockHeight),
+ RawLog: txResponse.Log,
+ Logs: func() json.RawMessage {
+ if txResponse.Code == 0 {
+ return []byte(txResponse.Log)
+ } else {
+ out, _ := json.Marshal([]string{})
+ return out
+ }
+ }(),
+ TxHash: accountTx.TxHash,
+ Timestamp: accountTx.Timestamp,
+ Tx: txRecord.Tx,
+ }
+
+ txs = append(txs, txRes)
+ currentLimit += 1
+ if currentLimit >= limit {
+ break
+ }
+ iter.Next()
+ }
+ return txs, nil
+}

mantlemint/indexer/accounttx/client.go

@@ -0,0 +1,51 @@
+package accounttx
+
+import (
+ tmdb "github.com/cometbft/cometbft-db"
+ tmjson "github.com/cometbft/cometbft/libs/json"
+ "github.com/gorilla/mux"
+ "github.com/terra-money/feather-core/mantlemint/indexer"
+ "net/http"
+ "strconv"
+)
+
+var (
+ defaultLimit = uint64(100)
+ defaultOffset = uint64(0)
+ EndpointGETAccountTxs = "/index/account/{account}"
+)
+
+var RegisterRESTRoute = indexer.CreateRESTRoute(func(router *mux.Router, indexerDB tmdb.DB) {
+ router.HandleFunc(EndpointGETAccountTxs, func(w http.ResponseWriter, r *http.Request) {
+ account, ok := mux.Vars(r)["account"]
+ if !ok {
+ http.Error(w, "invalid request: account not found", 400)
+ return
+ }
+ queries := r.URL.Query()
+ offset, err := strconv.ParseUint(queries.Get("offset"), 10, 64)
+ if err != nil {
+ offset = defaultOffset
+ }
+ limit, err := strconv.ParseUint(queries.Get("offset"), 10, 64)
+ if err != nil {
+ limit = defaultLimit
+ }
+ txs, err := getTxnsByAccount(indexerDB, account, offset, limit)
+ if err != nil {
+ http.Error(w, err.Error(), 500)
+ }
+
+ rxRes := &GetAccountTxsResponse{
+ Limit: limit,
+ Offset: offset,
+ Txs: txs,
+ }
+ res, err := tmjson.Marshal(rxRes)
+ if err != nil {
+ http.Error(w, err.Error(), 500)
+ }
+ w.WriteHeader(200)
+ w.Write(res)
+ })
+})

mantlemint/indexer/accounttx/types.go

@@ -0,0 +1,34 @@
+package accounttx
+
+import (
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ "github.com/terra-money/feather-core/mantlemint/indexer/tx"
+ "time"
+)
+
+type AccountTx struct {
+ TxHash string `json:"txhash"`
+ BlockHeight uint64 `json:"height"`
+ Timestamp time.Time `json:"timestamp"`
+}
+
+var (
+ AccountTxPrefix = []byte("account_tx/address:")
+)
+
+func GetAccountTxKeyByAddr(addr string) (key []byte) {
+ key = append(AccountTxPrefix, addr...)
+ return key
+}
+
+func GetAccountTxKey(addr string, blockHeight uint64, txIndex uint64) (key []byte) {
+ key = append(GetAccountTxKeyByAddr(addr), sdk.Uint64ToBigEndian(blockHeight)...)
+ key = append(key, sdk.Uint64ToBigEndian(txIndex)...)
+ return key
+}
+
+type GetAccountTxsResponse struct {
+ Limit uint64 `json:"limit"`
+ Offset uint64 `json:"offset"`
+ Txs []tx.TxByHeightRecord `json:"txs"`
+}

mantlemint/indexer/block/block.go

@@ -25,3 +25,24 @@ var IndexBlock = indexer.CreateIndexer(func(indexerDB safe_batch.SafeBatchDB, bl
 
  return indexerDB.Set(getKey(uint64(block.Height)), recordJSON)
 })
+
+func IterateBlocks(indexerDb safe_batch.SafeBatchDB, start int64, end int64, cb func(block *tm.Block) (stop bool)) (err error) {
+ iter, err := indexerDb.Iterator(getKey(uint64(start)), getKey(uint64(end)))
+ if err != nil {
+ return err
+ }
+ for iter.Valid() {
+ b := iter.Value()
+ var block BlockRecord
+ err := tmjson.Unmarshal(b, &block)
+ if err != nil {
+ return err
+ }
+ stop := cb(block.Block)
+ if stop {
+ return nil
+ }
+ iter.Next()
+ }
+ return nil
+}