Fix: Handle correctly keys on Get/Put Value and Get/Put IPNS.

client/getipns.go

@@ -4,6 +4,8 @@ import (
 	"context"
 
 	"github.com/ipfs/go-delegated-routing/gen/proto"
+	ipns "github.com/ipfs/go-ipns"
+	"github.com/libp2p/go-libp2p-core/peer"
 	"github.com/libp2p/go-libp2p-core/routing"
 )
 
@@ -21,7 +23,7 @@ func (fp *Client) GetIPNS(ctx context.Context, id []byte) ([]byte, error) {
 	if len(records) == 0 {
 		return nil, routing.ErrNotFound
 	}
-	best, err := fp.validator.Select(string(id), records)
+	best, err := fp.validator.Select(ipns.RecordKey(peer.ID(id)), records)
 	if err != nil {
 		return nil, err
 	}
@@ -66,7 +68,7 @@ func (fp *Client) GetIPNSAsync(ctx context.Context, id []byte) (<-chan GetIPNSAs
 					continue
 				}
 
-				if err = fp.validator.Validate(string(id), r0.Resp.Record); err != nil {
+				if err = fp.validator.Validate(ipns.RecordKey(peer.ID(id)), r0.Resp.Record); err != nil {
 					r1.Err = err
 					select {
 					case <-ctx.Done():

client/putipns.go

@@ -2,12 +2,19 @@ package client
 
 import (
 	"context"
+	"fmt"
 
 	"github.com/ipfs/go-delegated-routing/gen/proto"
+	"github.com/libp2p/go-libp2p-core/peer"
 )
 
 func (fp *Client) PutIPNS(ctx context.Context, id []byte, record []byte) error {
-	_, err := fp.client.PutIPNS(ctx, &proto.PutIPNSRequest{ID: id, Record: record})
+	_, err := peer.IDFromBytes(id)
+	if err != nil {
+		return fmt.Errorf("invalid peer ID: %w", err)
+	}
+
+	_, err = fp.client.PutIPNS(ctx, &proto.PutIPNSRequest{ID: id, Record: record})
 	if err != nil {
 		return err
 	}
@@ -19,6 +26,11 @@ type PutIPNSAsyncResult struct {
 }
 
 func (fp *Client) PutIPNSAsync(ctx context.Context, id []byte, record []byte) (<-chan PutIPNSAsyncResult, error) {
+	_, err := peer.IDFromBytes(id)
+	if err != nil {
+		return nil, fmt.Errorf("invalid peer ID: %w", err)
+	}
+
 	ch0, err := fp.client.PutIPNS_Async(ctx, &proto.PutIPNSRequest{ID: id, Record: record})
 	if err != nil {
 		return nil, err

client/store.go

@@ -2,20 +2,41 @@ package client
 
 import (
 	"context"
+	"fmt"
 
+	"github.com/ipfs/go-ipns"
 	"github.com/libp2p/go-libp2p-core/routing"
+	record "github.com/libp2p/go-libp2p-record"
 )
 
 var _ routing.ValueStore = &Client{}
 
 // PutValue adds value corresponding to given Key.
 func (c *Client) PutValue(ctx context.Context, key string, val []byte, opts ...routing.Option) error {
-	return c.PutIPNS(ctx, []byte(key), val)
+	ns, path, err := record.SplitKey(key)
+	if err != nil {
+		return fmt.Errorf("invalid key: %w", err)
+	}
+
+	if ns != "ipns" {
+		return ipns.ErrKeyFormat
+	}
+
+	return c.PutIPNS(ctx, []byte(path), val)
 }
 
 // GetValue searches for the value corresponding to given Key.
 func (c *Client) GetValue(ctx context.Context, key string, opts ...routing.Option) ([]byte, error) {
-	return c.GetIPNS(ctx, []byte(key))
+	ns, path, err := record.SplitKey(key)
+	if err != nil {
+		return nil, fmt.Errorf("invalid key: %w", err)
+	}
+
+	if ns != "ipns" {
+		return nil, ipns.ErrKeyFormat
+	}
+
+	return c.GetIPNS(ctx, []byte(path))
 }
 
 // SearchValue searches for better and better values from this value
@@ -29,7 +50,16 @@ func (c *Client) GetValue(ctx context.Context, key string, opts ...routing.Optio
 // Implementations of this methods won't return ErrNotFound. When a value
 // couldn't be found, the channel will get closed without passing any results
 func (c *Client) SearchValue(ctx context.Context, key string, opts ...routing.Option) (<-chan []byte, error) {
-	resChan, err := c.GetIPNSAsync(ctx, []byte(key))
+	ns, path, err := record.SplitKey(key)
+	if err != nil {
+		return nil, fmt.Errorf("invalid key: %w", err)
+	}
+
+	if ns != "ipns" {
+		return nil, ipns.ErrKeyFormat
+	}
+
+	resChan, err := c.GetIPNSAsync(ctx, []byte(path))
 	if err != nil {
 		return nil, err
 	}

test/clientserver_test.go

@@ -73,7 +73,7 @@ func testClientServer(t *testing.T, numIter int) (avgLatency time.Duration, delt
 		}
 
 		// exercise GetIPNS
-		record, err := c.GetIPNS(context.Background(), testIPNSID)
+		record, err := c.GetIPNS(context.Background(), []byte(testPeerIDFromIPNS))
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -102,7 +102,7 @@ func testClientServer(t *testing.T, numIter int) (avgLatency time.Duration, delt
 		}
 
 		// exercise PutIPNS
-		err = c.PutIPNS(context.Background(), testIPNSID, testIPNSRecord)
+		err = c.PutIPNS(context.Background(), []byte(testPeerIDFromIPNS), testIPNSRecord)
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -189,7 +189,7 @@ func TestCancelContext(t *testing.T) {
 
 	ctx, cancel := context.WithCancel(context.Background())
 
-	gir, err := c.GetIPNSAsync(ctx, testIPNSID)
+	gir, err := c.GetIPNSAsync(ctx, []byte(testPeerIDFromIPNS))
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -203,7 +203,7 @@ func TestCancelContext(t *testing.T) {
 
 	ctx, cancel = context.WithCancel(context.Background())
 
-	pir, err := c.PutIPNSAsync(ctx, testIPNSID, testIPNSRecord)
+	pir, err := c.PutIPNSAsync(ctx, []byte(testPeerIDFromIPNS), testIPNSRecord)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -294,8 +294,9 @@ var (
 		Addrs: []multiaddr.Multiaddr{testMultiaddr},
 	}
 	// IPNS
-	testIPNSID     []byte
-	testIPNSRecord []byte
+	testPeerIDFromIPNS peer.ID
+	testIPNSID         []byte
+	testIPNSRecord     []byte
 )
 
 // TestMain generates a valid IPNS key and record for testing purposes.
@@ -308,6 +309,7 @@ func TestMain(m *testing.M) {
 	if err != nil {
 		panic(err)
 	}
+	testPeerIDFromIPNS = peerID
 	testIPNSID = []byte(ipns.RecordKey(peerID))
 	entry, err := ipns.Create(privateKey, testIPNSID, 0, time.Now().Add(time.Hour), time.Hour)
 	if err != nil {

version.json

@@ -1,3 +1,3 @@
 {
-  "version": "v0.2.2"
+  "version": "v0.3.0"
 }