chore: using msg hash in hex and adding store test

waku/common/envelope.go

@@ -3,7 +3,6 @@ package common
 import (
 	"encoding/json"
 
-	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/waku-org/go-waku/waku/v2/protocol/pb"
 )
 
@@ -13,13 +12,13 @@ import (
 type Envelope interface {
 	Message() *pb.WakuMessage
 	PubsubTopic() string
-	Hash() pb.MessageHash
+	Hash() MessageHash
 }
 
 type envelopeImpl struct {
 	msg   *pb.WakuMessage
 	topic string
-	hash  pb.MessageHash
+	hash  MessageHash
 }
 
 type tmpWakuMessageJson struct {
@@ -35,7 +34,7 @@ type tmpWakuMessageJson struct {
 type tmpEnvelopeStruct struct {
 	WakuMessage tmpWakuMessageJson `json:"wakuMessage"`
 	PubsubTopic string             `json:"pubsubTopic"`
-	MessageHash string             `json:"messageHash"`
+	MessageHash MessageHash        `json:"messageHash"`
 }
 
 // NewEnvelope creates a new Envelope from a json string generated in nwaku
@@ -46,7 +45,6 @@ func NewEnvelope(jsonEventStr string) (Envelope, error) {
 		return nil, err
 	}
 
-	hash, err := hexutil.Decode(tmpEnvelopeStruct.MessageHash)
 	if err != nil {
 		return nil, err
 	}
@@ -62,7 +60,7 @@ func NewEnvelope(jsonEventStr string) (Envelope, error) {
 			RateLimitProof: tmpEnvelopeStruct.WakuMessage.RateLimitProof,
 		},
 		topic: tmpEnvelopeStruct.PubsubTopic,
-		hash:  pb.ToMessageHash(hash),
+		hash:  tmpEnvelopeStruct.MessageHash,
 	}, nil
 }
 
@@ -74,6 +72,6 @@ func (e *envelopeImpl) PubsubTopic() string {
 	return e.topic
 }
 
-func (e *envelopeImpl) Hash() pb.MessageHash {
+func (e *envelopeImpl) Hash() MessageHash {
 	return e.hash
 }

waku/common/message_hash.go

@@ -0,0 +1,39 @@
+package common
+
+import (
+	"encoding/hex"
+	"errors"
+	"fmt"
+)
+
+// MessageHash represents an unique identifier for a message within a pubsub topic
+type MessageHash string
+
+func ToMessageHash(val string) (MessageHash, error) {
+	if len(val) == 0 {
+		return "", errors.New("empty string not allowed")
+	}
+
+	if len(val) < 2 || val[:2] != "0x" {
+		return "", errors.New("string must start with 0x")
+	}
+
+	// Remove "0x" prefix for hex decoding
+	hexStr := val[2:]
+
+	// Verify the remaining string is valid hex
+	_, err := hex.DecodeString(hexStr)
+	if err != nil {
+		return "", fmt.Errorf("invalid hex string: %v", err)
+	}
+
+	return MessageHash(val), nil
+}
+
+func (h MessageHash) String() string {
+	return string(h)
+}
+
+func (h MessageHash) Bytes() ([]byte, error) {
+	return hex.DecodeString(string(h))
+}

waku/common/store.go

@@ -0,0 +1,28 @@
+package common
+
+type StoreQueryRequest struct {
+	RequestId         string         `json:"request_id"`
+	IncludeData       bool           `json:"include_data"`
+	PubsubTopic       string         `json:"pubsub_topic,omitempty"`
+	ContentTopics     *[]string      `json:"content_topics,omitempty"`
+	TimeStart         *int64         `json:"time_start,omitempty"`
+	TimeEnd           *int64         `json:"time_end,omitempty"`
+	MessageHashes     *[]MessageHash `json:"message_hashes,omitempty"`
+	PaginationCursor  *MessageHash   `json:"pagination_cursor,omitempty"`
+	PaginationForward bool           `json:"pagination_forward"`
+	PaginationLimit   *uint64        `json:"pagination_limit,omitempty"`
+}
+
+type StoreMessageResponse struct {
+	WakuMessage *tmpWakuMessageJson `json:"message"`
+	PubsubTopic string              `json:"pubsubTopic"`
+	MessageHash MessageHash         `json:"messageHash"`
+}
+
+type StoreQueryResponse struct {
+	RequestId        string                  `json:"requestId,omitempty"`
+	StatusCode       *uint32                 `json:"statusCode,omitempty"`
+	StatusDesc       string                  `json:"statusDesc,omitempty"`
+	Messages         *[]StoreMessageResponse `json:"messages,omitempty"`
+	PaginationCursor MessageHash             `json:"paginationCursor,omitempty"`
+}

waku/nwaku.go

@@ -323,15 +323,13 @@ import (
 	"time"
 	"unsafe"
 
-	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/p2p/enode"
 	"github.com/libp2p/go-libp2p/core/peer"
 	libp2pproto "github.com/libp2p/go-libp2p/core/protocol"
 	"github.com/multiformats/go-multiaddr"
 	"github.com/waku-org/go-waku/waku/v2/protocol/pb"
-	storepb "github.com/waku-org/go-waku/waku/v2/protocol/store/pb"
 	"github.com/waku-org/go-waku/waku/v2/utils"
 	"github.com/waku-org/waku-go-bindings/waku/common"
 	"go.uber.org/zap"
@@ -347,6 +345,7 @@ type WakuConfig struct {
 	Nodekey                     string           `json:"nodekey,omitempty"`
 	Relay                       bool             `json:"relay,omitempty"`
 	Store                       bool             `json:"store,omitempty"`
+	LegacyStore                 bool             `json:"legacyStore"`
 	Storenode                   string           `json:"storenode,omitempty"`
 	StoreMessageRetentionPolicy string           `json:"storeMessageRetentionPolicy,omitempty"`
 	StoreMessageDbUrl           string           `json:"storeMessageDbUrl,omitempty"`
@@ -827,7 +826,7 @@ func (n *WakuNode) Version() (string, error) {
 	return "", errors.New(errMsg)
 }
 
-func (n *WakuNode) StoreQuery(ctx context.Context, storeRequest *storepb.StoreQueryRequest, peerInfo peer.AddrInfo) (*storepb.StoreQueryResponse, error) {
+func (n *WakuNode) StoreQuery(ctx context.Context, storeRequest *common.StoreQueryRequest, peerInfo peer.AddrInfo) (*common.StoreQueryResponse, error) {
 	timeoutMs := getContextTimeoutMilliseconds(ctx)
 
 	b, err := json.Marshal(storeRequest)
@@ -856,24 +855,24 @@ func (n *WakuNode) StoreQuery(ctx context.Context, storeRequest *storepb.StoreQu
 
 	if C.getRet(resp) == C.RET_OK {
 		jsonResponseStr := C.GoStringN(C.getMyCharPtr(resp), C.int(C.getMyCharLen(resp)))
-		storeQueryResponse := &storepb.StoreQueryResponse{}
-		err = json.Unmarshal([]byte(jsonResponseStr), storeQueryResponse)
+		storeQueryResponse := common.StoreQueryResponse{}
+		err = json.Unmarshal([]byte(jsonResponseStr), &storeQueryResponse)
 		if err != nil {
 			return nil, err
 		}
-		return storeQueryResponse, nil
+		return &storeQueryResponse, nil
 	}
 	errMsg := "error WakuStoreQuery: " +
 		C.GoStringN(C.getMyCharPtr(resp), C.int(C.getMyCharLen(resp)))
 	return nil, errors.New(errMsg)
 }
 
-func (n *WakuNode) RelayPublish(ctx context.Context, message *pb.WakuMessage, pubsubTopic string) (pb.MessageHash, error) {
+func (n *WakuNode) RelayPublish(ctx context.Context, message *pb.WakuMessage, pubsubTopic string) (common.MessageHash, error) {
 	timeoutMs := getContextTimeoutMilliseconds(ctx)
 
 	jsonMsg, err := json.Marshal(message)
 	if err != nil {
-		return pb.MessageHash{}, err
+		return common.MessageHash(""), err
 	}
 
 	wg := sync.WaitGroup{}
@@ -890,14 +889,14 @@ func (n *WakuNode) RelayPublish(ctx context.Context, message *pb.WakuMessage, pu
 	wg.Wait()
 	if C.getRet(resp) == C.RET_OK {
 		msgHash := C.GoStringN(C.getMyCharPtr(resp), C.int(C.getMyCharLen(resp)))
-		msgHashBytes, err := hexutil.Decode(msgHash)
+		parsedMsgHash, err := common.ToMessageHash(msgHash)
 		if err != nil {
-			return pb.MessageHash{}, err
+			return common.MessageHash(""), err
 		}
-		return pb.ToMessageHash(msgHashBytes), nil
+		return parsedMsgHash, nil
 	}
 	errMsg := "WakuRelayPublish: " + C.GoStringN(C.getMyCharPtr(resp), C.int(C.getMyCharLen(resp)))
-	return pb.MessageHash{}, errors.New(errMsg)
+	return common.MessageHash(""), errors.New(errMsg)
 }
 
 func (n *WakuNode) DnsDiscovery(ctx context.Context, enrTreeUrl string, nameDnsServer string) ([]multiaddr.Multiaddr, error) {