feature/kip-87 -> release/v0.4.42

RELEASE.md

@@ -1,5 +1,5 @@
 
 Features:
 
-* Implement QueryUndelegations endpoint
-* Bump sekai version to v0.3.38
+* Implement KIP-87 : broadcast metamask coin send transaction to sekai
+* Implement KIP-87 : broadcast eip-712 signed transaction to sekai

config/constants.go

@@ -1,10 +1,18 @@
 package config
 
 const (
-	InterxVersion = "v0.4.41"
+	InterxVersion = "v0.4.42"
 	SekaiVersion  = "v0.3.38"
 	CosmosVersion = "v0.47.5"
 
+	DefaultChainID           = 8789
+	DefaultKiraAddrPrefix    = "kira"
+	DefaultKiraValAddrPrefix = "kiravaloper"
+	DefaultKiraDenom         = "ukex"
+
+	MetamaskEndpoint     = "/api/kira/evm"
+	RegisterAddrEndpoint = "/api/kira/evm/register_address/{eth_addr}{cosmos_addr}"
+
 	QueryDashboard = "/api/dashboard"
 
 	QueryAccounts        = "/api/kira/accounts/{address}"

gateway/kira/main.go

@@ -1,6 +1,7 @@
 package kira
 
 import (
+	"github.com/KiraCore/interx/gateway/kira/metamask"
 	"github.com/gorilla/mux"
 	"github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
 )
@@ -18,4 +19,5 @@ func RegisterRequest(router *mux.Router, gwCosmosmux *runtime.ServeMux, rpcAddr
 	RegisterKiraSpendingRoutes(router, gwCosmosmux, rpcAddr)
 	RegisterKiraUbiRoutes(router, gwCosmosmux, rpcAddr)
 	RegisterKiraMultiStakingRoutes(router, gwCosmosmux, rpcAddr)
+	metamask.RegisterKiraMetamaskRoutes(router, gwCosmosmux, rpcAddr)
 }

gateway/kira/metamask/cosmosaccountinfo.go

@@ -0,0 +1,31 @@
+package metamask
+
+import (
+	"net/http"
+
+	"github.com/KiraCore/interx/common"
+	interxtypes "github.com/KiraCore/interx/types"
+	"github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
+)
+
+func GetAccountInfo(params EthGetTransactionCount, gwCosmosmux *runtime.ServeMux, r *http.Request) (uint64, uint64, error) {
+	bech32Addr, err := hex2bech32(params.From, TypeKiraAddr)
+	if err != nil {
+		return 0, 0, err
+	}
+
+	accountNumber, sequence := common.GetAccountNumberSequence(gwCosmosmux, r, bech32Addr)
+
+	return accountNumber, sequence, nil
+}
+
+func GetBalance(params EthGetBalanceParams, gwCosmosmux *runtime.ServeMux, r *http.Request) []interxtypes.Coin {
+	bech32Addr, err := hex2bech32(params.From, TypeKiraAddr)
+	if err != nil {
+		return nil
+	}
+
+	balances := common.GetAccountBalances(gwCosmosmux, r.Clone(r.Context()), bech32Addr)
+
+	return balances
+}

gateway/kira/metamask/cosmosblockinfo.go

@@ -0,0 +1,162 @@
+package metamask
+
+import (
+	"crypto/sha256"
+	"encoding/base64"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/KiraCore/interx/common"
+	types "github.com/cometbft/cometbft/proto/tendermint/types"
+)
+
+const (
+	BlockQueryByNumber = iota
+	BLockQueryByHash
+)
+
+type PartSetHeader struct {
+	Total uint32 `json:"total,omitempty"`
+	Hash  []byte `json:"hash,omitempty"`
+}
+
+type BlockID struct {
+	Hash          string        `json:"hash,omitempty"`
+	PartSetHeader PartSetHeader `json:"part_set_header"`
+}
+
+type Consensus struct {
+	Block uint64 `json:"block,string,omitempty"`
+	App   uint64 `json:"app,string,omitempty"`
+}
+
+type Header struct {
+	// basic block info
+	Version Consensus `json:"version"`
+	ChainID string    `json:"chain_id,omitempty"`
+	Height  int64     `json:"height,string,omitempty"`
+	Time    time.Time `json:"time"`
+	// prev block info
+	LastBlockId types.BlockID `json:"last_block_id"`
+	// hashes of block data
+	LastCommitHash string `json:"last_commit_hash,omitempty"`
+	DataHash       string `json:"data_hash,omitempty"`
+	// hashes from the app output from the prev block
+	ValidatorsHash     string `json:"validators_hash,omitempty"`
+	NextValidatorsHash string `json:"next_validators_hash,omitempty"`
+	ConsensusHash      string `json:"consensus_hash,omitempty"`
+	AppHash            string `json:"app_hash,omitempty"`
+	LastResultsHash    string `json:"last_results_hash,omitempty"`
+	// consensus info
+	EvidenceHash string `json:"evidence_hash,omitempty"`
+	// proposer_address is the original block proposer address, formatted as a Bech32 string.
+	// In Tendermint, this type is `bytes`, but in the SDK, we convert it to a Bech32 string
+	// for better UX.
+	ProposerAddress string `json:"proposer_address,omitempty"`
+}
+
+type Commit struct {
+	Height     int64             `json:"height,string,omitempty"`
+	Round      int32             `json:"round,omitempty"`
+	BlockID    BlockID           `json:"block_id"`
+	Signatures []types.CommitSig `json:"signatures"`
+}
+
+type Data struct {
+	// Txs that will be applied by state @ block.Height+1.
+	// NOTE: not all txs here are valid.  We're just agreeing on the order first.
+	// This means that block.AppHash does not include these txs.
+	Txs []string `protobuf:"bytes,1,rep,name=txs,proto3" json:"txs,omitempty"`
+}
+
+type Block struct {
+	Header     Header             `json:"header"`
+	Data       Data               `json:"data"`
+	Evidence   types.EvidenceList `json:"evidence"`
+	LastCommit Commit             `json:"last_commit,omitempty"`
+}
+
+type CosmosBlockInfo struct {
+	BlockId BlockID `json:"block_id,omitempty"`
+	// Since: cosmos-sdk 0.47
+	SdkBlock Block `json:"block,omitempty"`
+}
+
+func GetBlockNumber(rpcAddr string) (int, error) {
+	sentryStatus := common.GetKiraStatus((rpcAddr))
+	currentHeight, err := strconv.Atoi(sentryStatus.SyncInfo.LatestBlockHeight)
+	return currentHeight, err
+}
+
+func GetBlockByNumberOrHash(blockParam string, rpcAddr string, queryType int) (CosmosBlockInfo, []string, interface{}) {
+	var responseData, blockErr interface{}
+	var statusCode int
+	if queryType == BlockQueryByNumber {
+		var blockNum int64
+		var err error
+		if strings.Contains(blockParam, "0x") {
+			blockNum, err = hex2int64(blockParam)
+		} else {
+			blockNum, err = strconv.ParseInt(blockParam, 10, 64)
+		}
+		if err != nil {
+			return CosmosBlockInfo{}, nil, err
+		}
+
+		responseData, blockErr, statusCode = queryBlockByHeight(rpcAddr, strconv.Itoa(int(blockNum)))
+	} else if queryType == BLockQueryByHash {
+		if !strings.Contains(blockParam, "0x") {
+			blockParam = "0x" + blockParam
+		}
+		responseData, blockErr, statusCode = queryBlockByHash(rpcAddr, blockParam)
+	}
+	if blockErr != nil {
+		return CosmosBlockInfo{}, nil, blockErr
+	}
+
+	if statusCode != 200 {
+		return CosmosBlockInfo{}, nil, fmt.Errorf("request faield, status code - %d", statusCode)
+	}
+
+	jsonData, err := json.Marshal(responseData)
+	if err != nil {
+		return CosmosBlockInfo{}, nil, err
+	}
+
+	response := CosmosBlockInfo{}
+	err = json.Unmarshal(jsonData, &response)
+	if err != nil {
+		return CosmosBlockInfo{}, nil, err
+	}
+
+	txhashes := []string{}
+	txs := response.SdkBlock.Data.Txs
+	for _, txStr := range txs {
+		txBz, err := base64.StdEncoding.DecodeString(txStr)
+		if err != nil {
+			return CosmosBlockInfo{}, nil, err
+		}
+		converted := []byte(txBz)
+		hasher := sha256.New()
+		hasher.Write(converted)
+		txhashes = append(txhashes, "0x"+hex.EncodeToString(hasher.Sum(nil)))
+	}
+
+	return response, txhashes, nil
+}
+
+func queryBlockByHeight(rpcAddr string, height string) (interface{}, interface{}, int) {
+	success, err, statusCode := common.MakeTendermintRPCRequest(rpcAddr, "/block", fmt.Sprintf("height=%s", height))
+
+	return success, err, statusCode
+}
+
+func queryBlockByHash(rpcAddr string, height string) (interface{}, interface{}, int) {
+	success, err, statusCode := common.MakeTendermintRPCRequest(rpcAddr, "/block_by_hash", fmt.Sprintf("hash=%s", height))
+
+	return success, err, statusCode
+}

gateway/kira/metamask/cosmostxinfo.go

@@ -0,0 +1,120 @@
+package metamask
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	"github.com/KiraCore/interx/common"
+)
+
+// Attribute is a struct that represents an attribute in the JSON data
+type Attribute struct {
+	Key   string `json:"key"`
+	Value string `json:"value"`
+}
+
+// Event is a struct that represents an event in the JSON data
+type Event struct {
+	Type       string      `json:"type"`
+	Attributes []Attribute `json:"attributes"`
+}
+
+// Msg is a struct that represents a message in the JSON data
+type LogInfo struct {
+	MsgIndex int     `json:"msg_index"`
+	Events   []Event `json:"events"`
+}
+
+// map[msgIndex][event_type][attribute_key]
+type LogInfoForMap struct {
+	LogInfo map[int]map[string]map[string]string
+}
+
+type Log struct {
+	logForMap    map[int]LogInfoForMap
+	logForString string
+}
+
+type TxInfo struct {
+	Hash     string `json:"hash"`
+	Height   string `json:"height"`
+	Index    int    `json:"index"`
+	TxResult struct {
+		Code      int    `json:"code"`
+		Data      string `json:"data"`
+		Log       string `json:"log"`
+		Info      string `json:"info"`
+		GasWanted string `json:"gas_wanted"`
+		GasUsed   string `json:"gas_used"`
+		Events    []struct {
+			Type       string `json:"type"`
+			Attributes []struct {
+				Key   string `json:"key"`
+				Value string `json:"value"`
+				Index bool   `json:"index"`
+			} `json:"attributes"`
+		} `json:"events"`
+		Codespace string `json:"codespace"`
+	} `json:"tx_result"`
+	Tx string `json:"tx"`
+}
+
+func GetTxInfo(txHash string, rpcAddr string) (TxInfo, Log, interface{}) {
+	responseData, err, statusCode := queryTxByHash(rpcAddr, txHash)
+	logResult := Log{}
+
+	if err != nil {
+		return TxInfo{}, logResult, err
+	}
+
+	if statusCode != 200 {
+		return TxInfo{}, logResult, fmt.Errorf("request faield, status code - %d", statusCode)
+	}
+
+	jsonData, err := json.Marshal(responseData)
+	if err != nil {
+		return TxInfo{}, logResult, err
+	}
+
+	response := TxInfo{}
+	err = json.Unmarshal(jsonData, &response)
+	if err != nil {
+		return TxInfo{}, logResult, err
+	}
+
+	var logInfos []LogInfo
+
+	// Unmarshal the JSON data to the msgs slice
+	err = json.Unmarshal([]byte(response.TxResult.Log), &logInfos)
+	logResult.logForString = response.TxResult.Log
+	if err != nil {
+		return response, logResult, nil
+	}
+
+	logInfosForMap := map[int]LogInfoForMap{}
+	for i, logInfo := range logInfos {
+		logInfosForMap[i] = LogInfoForMap{LogInfo: make(map[int]map[string]map[string]string)}
+		for _, event := range logInfo.Events {
+			if logInfosForMap[i].LogInfo[logInfo.MsgIndex] == nil {
+				logInfosForMap[i].LogInfo[logInfo.MsgIndex] = make(map[string]map[string]string)
+			}
+			if logInfosForMap[i].LogInfo[logInfo.MsgIndex][event.Type] == nil {
+				logInfosForMap[i].LogInfo[logInfo.MsgIndex][event.Type] = make(map[string]string)
+			}
+			for _, attribute := range event.Attributes {
+				logInfosForMap[i].LogInfo[logInfo.MsgIndex][event.Type][attribute.Key] = attribute.Value
+			}
+		}
+	}
+
+	logResult.logForMap = logInfosForMap
+	return response, logResult, nil
+}
+
+func queryTxByHash(rpcAddr string, hash string) (interface{}, interface{}, int) {
+	if !strings.HasPrefix(hash, "0x") {
+		hash = "0x" + hash
+	}
+	return common.MakeTendermintRPCRequest(rpcAddr, "/tx", fmt.Sprintf("hash=%s", hash))
+}