#16 refinements to data Keeper API

go.mod

@@ -10,6 +10,7 @@ require (
 	github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973 // indirect
 	github.com/bgentry/speakeasy v0.1.0 // indirect
 	github.com/btcsuite/btcd v0.0.0-20181130015935-7d2daa5bfef2 // indirect
+	github.com/btcsuite/btcutil v0.0.0-20180706230648-ab6388e0c60a
 	github.com/campoy/unique v0.0.0-20180121183637-88950e537e7e
 	github.com/cosmos/cosmos-sdk v0.32.0
 	//github.com/cosmos/cosmos-sdk v0.32.0

types/types.go

@@ -3,6 +3,7 @@ package types
 import (
 	"fmt"
 	"github.com/regen-network/regen-ledger/util"
+	"github.com/tendermint/tendermint/libs/bech32"
 	"net/url"
 )
 
@@ -21,6 +22,10 @@ type GeoAddress []byte
 
 type DataAddress []byte
 
+const (
+	DataAddressPrefixOnChainGraph byte = iota
+)
+
 // String returns the string URI representation mof the GeoAddress
 func (addr GeoAddress) String() string {
 	return util.MustEncodeBech32(Bech32GeoAddressPrefix, addr)
@@ -36,7 +41,13 @@ func (addr GeoAddress) URI() *url.URL {
 }
 
 func (addr DataAddress) String() string {
-	return util.MustEncodeBech32(Bech32DataAddressPrefix, addr)
+	switch addr[0] {
+	case DataAddressPrefixOnChainGraph:
+		return util.MustEncodeBech32(Bech32DataAddressPrefix, addr[1:])
+	default:
+		panic(fmt.Errorf("unknown address prefix %d", addr[0]))
+
+	}
 }
 
 func (addr DataAddress) URI() *url.URL {
@@ -46,3 +57,18 @@ func (addr DataAddress) URI() *url.URL {
 	}
 	return uri
 }
+
+func GetDataAddressOnChainGraph(hash []byte) DataAddress {
+	return append([]byte{DataAddressPrefixOnChainGraph}, hash...)
+}
+
+func MustDecodeDataURL(url string) DataAddress {
+	hrp, bz, err := bech32.DecodeAndConvert(url)
+	if err != nil {
+		panic(err)
+	}
+	if hrp == Bech32DataAddressPrefix {
+		return GetDataAddressOnChainGraph(bz)
+	}
+	panic("can't decode data URL")
+}

x/data/data_test.go

@@ -11,6 +11,7 @@ import (
 	"github.com/regen-network/regen-ledger/graph"
 	"github.com/regen-network/regen-ledger/graph/binary"
 	"github.com/regen-network/regen-ledger/graph/gen"
+	"github.com/regen-network/regen-ledger/types"
 	"github.com/regen-network/regen-ledger/x/data"
 	"github.com/regen-network/regen-ledger/x/schema"
 	schematest "github.com/regen-network/regen-ledger/x/schema/test"
@@ -63,21 +64,31 @@ func (s *Suite) TestStoreDataGraph() {
 			}
 			hash := graph.Hash(g1)
 
-			// check if we have exisitng data (because the generator repeats values)
-			bz := s.Keeper.GetData(s.Ctx, hash)
+			// check if we have existing data (because the generator repeats values)
+			addr := types.GetDataAddressOnChainGraph(hash)
+			bz, err := s.Keeper.GetData(s.Ctx, addr)
 			if bz == nil {
 				res := s.Handler(s.Ctx, data.MsgStoreGraph{Hash: hash, Data: buf.Bytes(), Signer: s.AnAddr})
 				if res.Code != sdk.CodeOK {
 					return false, fmt.Errorf("%+v", res)
 				}
 
+				url := res.Tags[0].Value
+				addr2 := types.MustDecodeDataURL(string(url))
+				if !bytes.Equal(addr, addr2) {
+					return false, fmt.Errorf("unexpected DataAddress %+v, %+v", []byte(addr), []byte(addr2))
+				}
+
 				// verify can't store same graph again
 				res = s.Handler(s.Ctx, data.MsgStoreGraph{Hash: hash, Data: buf.Bytes(), Signer: s.AnAddr})
 				if res.Code == sdk.CodeOK {
 					return false, fmt.Errorf("shouldn't be able to store the same graph twice")
 				}
 
-				bz = s.Keeper.GetData(s.Ctx, hash)
+				bz, err = s.Keeper.GetData(s.Ctx, addr)
+				if err != nil {
+					return false, err
+				}
 			}
 
 			g2, err := binary.DeserializeGraph(s.Resolver, bytes.NewBuffer(bz))

x/data/handler.go

@@ -1,7 +1,6 @@
 package data
 
 import (
-	"encoding/hex"
 	"fmt"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
@@ -21,14 +20,11 @@ func NewHandler(keeper Keeper) sdk.Handler {
 }
 
 func handleMsgStoreData(ctx sdk.Context, keeper Keeper, msg MsgStoreGraph) sdk.Result {
-	hash, err := keeper.StoreGraph(ctx, msg.Hash, msg.Data)
+	addr, err := keeper.StoreGraph(ctx, msg.Hash, msg.Data)
 	if err != nil {
 		return err.Result()
 	}
-	tags := sdk.EmptyTags()
-	tags.AppendTag("data.hash", hex.EncodeToString(hash))
-	return sdk.Result{
-		Data: hash,
-		Tags: tags,
-	}
+	res := sdk.Result{Data: addr}
+	res.Tags = res.Tags.AppendTag("data.address", addr.String())
+	return res
 }

x/data/keeper.go

@@ -28,13 +28,18 @@ func NewKeeper(dataStoreKey sdk.StoreKey, schemaKeeper schema.Keeper, cdc *codec
 	}
 }
 
-func (k Keeper) GetData(ctx sdk.Context, hash []byte) []byte {
+func (k Keeper) GetData(ctx sdk.Context, addr types.DataAddress) ([]byte, sdk.Error) {
 	store := ctx.KVStore(k.dataStoreKey)
-	bz := store.Get(hash)
-	if bz == nil {
-		return nil
+	bz := store.Get(addr)
+	if bz == nil || len(bz) < 1 {
+		return nil, sdk.ErrUnknownRequest("not found")
+	}
+	switch addr[0] {
+	case types.DataAddressPrefixOnChainGraph:
+		return bz, nil
+	default:
+		return nil, sdk.ErrUnknownRequest("bad address")
 	}
-	return bz
 }
 
 const (
@@ -53,12 +58,13 @@ func (k Keeper) StoreGraph(ctx sdk.Context, hash []byte, data []byte) (types.Dat
 		return nil, sdk.ErrUnknownRequest("incorrect graph hash")
 	}
 	store := ctx.KVStore(k.dataStoreKey)
-	existing := k.GetData(ctx, hash)
-	if existing != nil {
+	addr := types.GetDataAddressOnChainGraph(hash)
+	existing, err := k.GetData(ctx, addr)
+	if err == nil && existing != nil {
 		return nil, sdk.ErrUnknownRequest("already exists")
 	}
 	bytes := len(data)
 	ctx.GasMeter().ConsumeGas(gasPerByteStorage*uint64(bytes), "store data")
-	store.Set(hash, data)
-	return hash, nil
+	store.Set(addr, data)
+	return addr, nil
 }

x/data/querier.go

@@ -8,8 +8,7 @@ import (
 
 // query endpoints supported by the governance Querier
 const (
-	QueryData            = "get"
-	QueryDataBlockHeight = "block-height"
+	QueryData = "get"
 )
 
 func NewQuerier(keeper Keeper) sdk.Querier {
@@ -31,10 +30,13 @@ func fromHex(str string) []byte {
 	return bz
 }
 
-func queryData(ctx sdk.Context, path []string, req abci.RequestQuery, keeper Keeper) (res []byte, err sdk.Error) {
+func queryData(ctx sdk.Context, path []string, _ abci.RequestQuery, keeper Keeper) (res []byte, err sdk.Error) {
 	id := path[0]
 
-	value := keeper.GetData(ctx, fromHex(id))
+	value, err := keeper.GetData(ctx, fromHex(id))
+	if err != nil {
+		return nil, err
+	}
 
 	if len(value) == 0 {
 		return []byte{}, sdk.ErrUnknownRequest("could not resolve id")