bugfix/performance -> release/v0.4.43

.github/workflows/main.yml

@@ -16,7 +16,7 @@ jobs:
       id-token: write
       pull-requests: write
     container: 
-      image: ghcr.io/kiracore/docker/base-image:v0.11.2
+      image: ghcr.io/kiracore/docker/base-image:v0.13.5
     steps:
           # Work around https://github.com/actions/checkout/issues/760
           - name: Add safe.directory
@@ -120,11 +120,13 @@ jobs:
       pull-requests: write
     steps:
           # Install the cosign tool
-          # ref.: https://github.com/sigstore/cosign-installer, v2.2.0
+          # ref.: https://github.com/sigstore/cosign-installer, v3.2.0
           - name: Install cosign
-            uses: sigstore/cosign-installer@d6a3abf1bdea83574e28d40543793018b6035605
+            uses: sigstore/cosign-installer@1fc5bd396d372bee37d608f955b336615edf79c8
             with:
-              cosign-release: 'v1.7.2'
+              cosign-release: 'v2.0.0'
+          - name: Confirm installation!
+            run: cosign version
           - name: Download artifacts
             uses: actions/[email protected]
             with:
@@ -189,7 +191,7 @@ jobs:
               COSIGN_PASSWORD: ${{ secrets.COSIGN_PASSWORD }}
             run: |
               echo "$KEY" > ../cosign.key
-              for FILE in *; do FILE_NAME=$(basename $FILE); cosign sign-blob --key=../cosign.key --output-signature=./${FILE_NAME}.sig ./$FILE_NAME; done
+              for FILE in *; do FILE_NAME=$(basename $FILE); cosign sign-blob --yes --key=../cosign.key --output-signature=./${FILE_NAME}.sig ./$FILE_NAME; done
               rm -fv ../cosign.key
           - name: Publish release
             if: |
@@ -258,4 +260,4 @@ jobs:
             env:
               MERGE_LABELS: "automerge"
               GITHUB_TOKEN: "${{ secrets.REPO_ACCESS }}"
-              LOG: "TRACE"
+              LOG: "TRACE"

.gitignore

@@ -3,9 +3,9 @@ cache/
 faucet.mnemonic
 interx.mnemonic
 proto-gen
+postman.json
 third_party/proto
-proto/cosmos
-proto/kira
+proto/
 codec/
 bin
 nfpm_*

RELEASE.md

@@ -1,4 +1,4 @@
 
 Features:
 
-* Optimize transactions endpoint
+* made sleep interval for snapshot checksum

common/api.go

@@ -16,11 +16,11 @@ import (
 	"github.com/KiraCore/interx/database"
 	"github.com/KiraCore/interx/global"
 	"github.com/KiraCore/interx/types"
+	tmjson "github.com/cometbft/cometbft/libs/json"
+	tmTypes "github.com/cometbft/cometbft/rpc/core/types"
+	tmJsonRPCTypes "github.com/cometbft/cometbft/rpc/jsonrpc/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
-	tmjson "github.com/tendermint/tendermint/libs/json"
-	tmTypes "github.com/tendermint/tendermint/rpc/core/types"
-	tmJsonRPCTypes "github.com/tendermint/tendermint/rpc/jsonrpc/types"
 )
 
 // MakeTendermintRPCRequest is a function to make GET request
@@ -309,7 +309,7 @@ func GetBlockNanoTime(rpcAddr string, height int64) (int64, error) {
 }
 
 // GetTokenAliases is a function to get token aliases
-func GetTokenAliases(gwCosmosmux *runtime.ServeMux, r *http.Request) []types.TokenAlias {
+func GetTokenAliases(gwCosmosmux *runtime.ServeMux, r *http.Request) ([]types.TokenAlias, string, string) {
 	// tokens, err := database.GetTokenAliases()
 	// if err == nil {
 	// 	return tokens
@@ -320,16 +320,18 @@ func GetTokenAliases(gwCosmosmux *runtime.ServeMux, r *http.Request) []types.Tok
 	r.Method = "GET"
 
 	// GetLogger().Info("[grpc-call] Entering grpc call: ", r.URL.Path)
-
 	recorder := httptest.NewRecorder()
 	gwCosmosmux.ServeHTTP(recorder, r)
 	resp := recorder.Result()
 
 	type TokenAliasesResponse struct {
-		Data []types.TokenAlias `json:"data"`
+		Data         []types.TokenAlias `json:"data"`
+		DefaultDenom string             `json:"defaultDenom"`
+		Bech32Prefix string             `json:"bech32Prefix"`
 	}
 
 	result := TokenAliasesResponse{}
+
 	err := json.NewDecoder(resp.Body).Decode(&result)
 	if err != nil {
 		GetLogger().Error("[grpc-call] Unable to decode response: ", err)
@@ -341,7 +343,7 @@ func GetTokenAliases(gwCosmosmux *runtime.ServeMux, r *http.Request) []types.Tok
 		GetLogger().Error("[grpc-call] Unable to save response")
 	}
 
-	return result.Data
+	return result.Data, result.DefaultDenom, result.Bech32Prefix
 }
 
 // GetTokenSupply is a function to get token supply

common/gateway.go

@@ -304,7 +304,7 @@ func WrapResponse(w http.ResponseWriter, request types.InterxRequest, response t
 	}
 }
 
-// ServeGRPC is a function to server GRPC
+// ServeGRPC is a function to serve GRPC
 func ServeGRPC(r *http.Request, gwCosmosmux *runtime.ServeMux) (interface{}, interface{}, int) {
 	recorder := httptest.NewRecorder()
 	gwCosmosmux.ServeHTTP(recorder, r)

common/gov.go

@@ -0,0 +1,175 @@
+package common
+
+import (
+	"encoding/json"
+
+	govTypes "github.com/KiraCore/interx/types/kira/gov"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+type NetworkProperties struct {
+	MinTxFee                     string `json:"minTxFee"`
+	MaxTxFee                     string `json:"maxTxFee"`
+	VoteQuorum                   string `json:"voteQuorum"`
+	MinimumProposalEndTime       string `json:"minimumProposalEndTime"`
+	ProposalEnactmentTime        string `json:"proposalEnactmentTime"`
+	MinProposalEndBlocks         string `json:"minProposalEndBlocks"`
+	MinProposalEnactmentBlocks   string `json:"minProposalEnactmentBlocks"`
+	EnableForeignFeePayments     bool   `json:"enableForeignFeePayments"`
+	MischanceRankDecreaseAmount  string `json:"mischanceRankDecreaseAmount"`
+	MaxMischance                 string `json:"maxMischance"`
+	MischanceConfidence          string `json:"mischanceConfidence"`
+	InactiveRankDecreasePercent  string `json:"inactiveRankDecreasePercent"`
+	MinValidators                string `json:"minValidators"`
+	PoorNetworkMaxBankSend       string `json:"poorNetworkMaxBankSend"`
+	UnjailMaxTime                string `json:"unjailMaxTime"`
+	EnableTokenWhitelist         bool   `json:"enableTokenWhitelist"`
+	EnableTokenBlacklist         bool   `json:"enableTokenBlacklist"`
+	MinIdentityApprovalTip       string `json:"minIdentityApprovalTip"`
+	UniqueIdentityKeys           string `json:"uniqueIdentityKeys"`
+	UbiHardcap                   string `json:"ubiHardcap"`
+	ValidatorsFeeShare           string `json:"validatorsFeeShare"`
+	InflationRate                string `json:"inflationRate"`
+	InflationPeriod              string `json:"inflationPeriod"`
+	UnstakingPeriod              string `json:"unstakingPeriod"`
+	MaxDelegators                string `json:"maxDelegators"`
+	MinDelegationPushout         string `json:"minDelegationPushout"`
+	SlashingPeriod               string `json:"slashingPeriod"`
+	MaxJailedPercentage          string `json:"maxJailedPercentage"`
+	MaxSlashingPercentage        string `json:"maxSlashingPercentage"`
+	MinCustodyReward             string `json:"minCustodyReward"`
+	MaxCustodyBufferSize         string `json:"maxCustodyBufferSize"`
+	MaxCustodyTxSize             string `json:"maxCustodyTxSize"`
+	AbstentionRankDecreaseAmount string `json:"abstentionRankDecreaseAmount"`
+	MaxAbstention                string `json:"maxAbstention"`
+	MinCollectiveBond            string `json:"minCollectiveBond"`
+	MinCollectiveBondingTime     string `json:"minCollectiveBondingTime"`
+	MaxCollectiveOutputs         string `json:"maxCollectiveOutputs"`
+	MinCollectiveClaimPeriod     string `json:"minCollectiveClaimPeriod"`
+	ValidatorRecoveryBond        string `json:"validatorRecoveryBond"`
+	MaxAnnualInflation           string `json:"maxAnnualInflation"`
+	MaxProposalTitleSize         string `json:"maxProposalTitleSize"`
+	MaxProposalDescriptionSize   string `json:"maxProposalDescriptionSize"`
+	MaxProposalPollOptionSize    string `json:"maxProposalPollOptionSize"`
+	MaxProposalPollOptionCount   string `json:"maxProposalPollOptionCount"`
+	MaxProposalReferenceSize     string `json:"maxProposalReferenceSize"`
+	MaxProposalChecksumSize      string `json:"maxProposalChecksumSize"`
+	MinDappBond                  string `json:"minDappBond"`
+	MaxDappBond                  string `json:"maxDappBond"`
+	DappBondDuration             string `json:"dappBondDuration"`
+	DappVerifierBond             string `json:"dappVerifierBond"`
+	DappAutoDenounceTime         string `json:"dappAutoDenounceTime"`
+}
+
+type NetworkPropertiesResponse struct {
+	Properties *NetworkProperties `json:"properties"`
+}
+
+func QueryVotersFromGrpcResult(success interface{}) ([]govTypes.Voter, error) {
+	result := struct {
+		Voters []struct {
+			Address     []byte                `json:"address,omitempty"`
+			Roles       []string              `json:"roles,omitempty"`
+			Status      string                `json:"status,omitempty"`
+			Votes       []string              `json:"votes,omitempty"`
+			Permissions *govTypes.Permissions `json:"permissions,omitempty"`
+			Skin        uint64                `json:"skin,string,omitempty"`
+		} `json:"voters,omitempty"`
+	}{}
+
+	byteData, err := json.Marshal(success)
+	if err != nil {
+		GetLogger().Error("[query-voters] Invalid response format: ", err)
+		return nil, err
+	}
+
+	err = json.Unmarshal(byteData, &result)
+	if err != nil {
+		GetLogger().Error("[query-voters] Invalid response format: ", err)
+		return nil, err
+	}
+
+	voters := make([]govTypes.Voter, 0)
+
+	for _, voter := range result.Voters {
+		newVoter := govTypes.Voter{}
+
+		newVoter.Address = sdk.MustBech32ifyAddressBytes(sdk.GetConfig().GetBech32AccountAddrPrefix(), voter.Address)
+		newVoter.Roles = voter.Roles
+		newVoter.Status = voter.Status
+		newVoter.Votes = voter.Votes
+
+		newVoter.Permissions.Blacklist = make([]string, 0)
+		for _, black := range voter.Permissions.Blacklist {
+			newVoter.Permissions.Blacklist = append(newVoter.Permissions.Blacklist, govTypes.PermValue_name[int32(black)])
+		}
+		newVoter.Permissions.Whitelist = make([]string, 0)
+		for _, white := range voter.Permissions.Whitelist {
+			newVoter.Permissions.Whitelist = append(newVoter.Permissions.Whitelist, govTypes.PermValue_name[int32(white)])
+		}
+
+		newVoter.Skin = voter.Skin
+
+		voters = append(voters, newVoter)
+	}
+	return voters, nil
+}
+
+func QueryVotesFromGrpcResult(success interface{}) ([]govTypes.Vote, error) {
+	result := struct {
+		Votes []struct {
+			ProposalID uint64 `json:"proposalID,string,omitempty"`
+			Voter      []byte `json:"voter,omitempty"`
+			Option     string `json:"option,omitempty"`
+		} `json:"votes,omitempty"`
+	}{}
+
+	byteData, err := json.Marshal(success)
+	if err != nil {
+		GetLogger().Error("[query-votes] Invalid response format: ", err)
+		return nil, err
+	}
+
+	err = json.Unmarshal(byteData, &result)
+	if err != nil {
+		GetLogger().Error("[query-votes] Invalid response format: ", err)
+		return nil, err
+	}
+
+	votes := make([]govTypes.Vote, 0)
+
+	for _, vote := range result.Votes {
+		newVote := govTypes.Vote{}
+
+		newVote.ProposalID = vote.ProposalID
+		newVote.Voter = sdk.MustBech32ifyAddressBytes(sdk.GetConfig().GetBech32AccountAddrPrefix(), vote.Voter)
+		newVote.Option = vote.Option
+
+		votes = append(votes, newVote)
+	}
+
+	return votes, nil
+}
+
+func QueryNetworkPropertiesFromGrpcResult(success interface{}) (NetworkPropertiesResponse, error) {
+	result := NetworkPropertiesResponse{}
+	byteData, err := json.Marshal(success)
+	if err != nil {
+		GetLogger().Error("[query-network-properties] Invalid response format", err)
+		return NetworkPropertiesResponse{}, err
+	}
+	err = json.Unmarshal(byteData, &result)
+	if err != nil {
+		GetLogger().Error("[query-network-properties] Invalid response format", err)
+		return NetworkPropertiesResponse{}, err
+	}
+
+	result.Properties.InactiveRankDecreasePercent = ConvertRate(result.Properties.InactiveRankDecreasePercent)
+	result.Properties.ValidatorsFeeShare = ConvertRate(result.Properties.ValidatorsFeeShare)
+	result.Properties.InflationRate = ConvertRate(result.Properties.InflationRate)
+	result.Properties.MaxSlashingPercentage = ConvertRate(result.Properties.MaxSlashingPercentage)
+	result.Properties.MaxAnnualInflation = ConvertRate(result.Properties.MaxAnnualInflation)
+	result.Properties.DappVerifierBond = ConvertRate(result.Properties.DappVerifierBond)
+
+	return result, nil
+}

common/helper.go

@@ -0,0 +1,26 @@
+package common
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+func ConvertRate(rateString string) string {
+	rate, _ := strconv.ParseFloat(rateString, 64)
+	rate = rate / 1000000000000000000.0
+	rateString = fmt.Sprintf("%g", rate)
+	if !strings.Contains(rateString, ".") {
+		rateString = rateString + ".0"
+	}
+	return rateString
+}
+
+func Include(arr []string, el string) bool {
+	for _, elm := range arr {
+		if elm == el {
+			return true
+		}
+	}
+	return false
+}

config/constants.go

@@ -1,9 +1,9 @@
 package config
 
 const (
-	InterxVersion = "v0.4.33"
-	SekaiVersion  = "v0.3.13.38"
-	CosmosVersion = "v0.45.10"
+	InterxVersion = "v0.4.43"
+	SekaiVersion  = "v0.3.40"
+	CosmosVersion = "v0.47.6"
 
 	QueryDashboard = "/api/dashboard"
 
@@ -42,6 +42,9 @@ const (
 	QueryIdentityRecordVerifyRequestsByApprover  = "/api/kira/gov/identity_verify_requests_by_approver/{approver}"
 	QueryAllIdentityRecordVerifyRequests         = "/api/kira/gov/all_identity_verify_requests"
 
+	QueryStakingPool           = "/api/kira/staking-pool"
+	QueryDelegations           = "/api/kira/delegations"
+	QueryUndelegations         = "/api/kira/undelegations"
 	QuerySpendingPools         = "/api/kira/spending-pools"
 	QuerySpendingPoolProposals = "/api/kira/spending-pool-proposals"
 

config/init.go

@@ -76,6 +76,7 @@ func getRPCSettings() RPCConfig {
 	config.API["GET"][QueryIdentityRecordVerifyRequestsByApprover] = defaultRPCSetting
 	config.API["GET"][QueryAllIdentityRecordVerifyRequests] = defaultRPCSetting
 	config.API["GET"][QuerySpendingPools] = defaultRPCSetting
+	config.API["GET"][QueryStakingPool] = defaultRPCSetting
 	config.API["GET"][QuerySpendingPoolProposals] = defaultRPCSetting
 	config.API["GET"][QueryUBIRecords] = defaultRPCSetting
 
@@ -230,6 +231,7 @@ func InitConfig(
 	nodeDiscoveryTendermintPort string,
 	nodeDiscoveryTimeout string,
 	nodeKey string,
+	snapshotInterval uint64,
 ) {
 	configFromFile := defaultConfig()
 
@@ -289,6 +291,8 @@ func InitConfig(
 		configFromFile.Faucet.FeeAmounts[denom] = amount
 	}
 
+	configFromFile.SnapshotInterval = snapshotInterval
+
 	bytes, err := json.MarshalIndent(&configFromFile, "", "  ")
 	if err != nil {
 		panic(err)