@agoric/cosmos 0.34.2-dev-ecf2d8e.0 → 0.35.0-other-dev-70beeb7.0

package/x/vbank/vbank_test.go

@@ -284,7 +284,7 @@ func Test_Receive_GetBalance(t *testing.T) {
 	}}
 	keeper, ctx := makeTestKit(nil, bank)
 	ch := NewPortHandler(AppModule{}, keeper)
-	ctlCtx := sdk.WrapSDKContext(ctx)
+	ctlCtx := &vm.ControllerContext{Context: ctx}
 
 	ret, err := ch.Receive(ctlCtx, `{
 		"type": "VBANK_GET_BALANCE",
@@ -312,7 +312,7 @@ func Test_Receive_Give(t *testing.T) {
 	}}
 	keeper, ctx := makeTestKit(nil, bank)
 	ch := NewPortHandler(AppModule{}, keeper)
-	ctlCtx := sdk.WrapSDKContext(ctx)
+	ctlCtx := &vm.ControllerContext{Context: ctx}
 
 	ret, err := ch.Receive(ctlCtx, `{
 		"type": "VBANK_GIVE",
@@ -349,7 +349,7 @@ func Test_Receive_GiveToRewardDistributor(t *testing.T) {
 	bank := &mockBank{}
 	keeper, ctx := makeTestKit(nil, bank)
 	ch := NewPortHandler(AppModule{}, keeper)
-	ctlCtx := sdk.WrapSDKContext(ctx)
+	ctlCtx := &vm.ControllerContext{Context: ctx}
 
 	tests := []struct {
 		name          string
@@ -474,7 +474,7 @@ func Test_Receive_Grab(t *testing.T) {
 	}}
 	keeper, ctx := makeTestKit(nil, bank)
 	ch := NewPortHandler(AppModule{}, keeper)
-	ctlCtx := sdk.WrapSDKContext(ctx)
+	ctlCtx := &vm.ControllerContext{Context: ctx}
 
 	ret, err := ch.Receive(ctlCtx, `{
 		"type": "VBANK_GRAB",
@@ -787,7 +787,7 @@ func Test_Module_Account(t *testing.T) {
 	keeper, ctx := makeTestKit(acct, nil)
 	am := AppModule{keeper: keeper}
 	ch := NewPortHandler(am, keeper)
-	ctlCtx := sdk.WrapSDKContext(ctx)
+	ctlCtx := &vm.ControllerContext{Context: ctx}
 
 	mod1 := "vbank/reserve"
 	ret, err := ch.Receive(ctlCtx, `{

package/x/vibc/ibc.go

@@ -1,7 +1,6 @@
 package vibc
 
 import (
-	"context"
 	"encoding/json"
 	"fmt"
 
@@ -64,9 +63,8 @@ func NewIBCModule(keeper Keeper) IBCModule {
 	}
 }
 
-func (ch IBCModule) Receive(cctx context.Context, str string) (ret string, err error) {
+func (ch IBCModule) Receive(ctx *vm.ControllerContext, str string) (ret string, err error) {
 	// fmt.Println("ibc.go downcall", str)
-	ctx := sdk.UnwrapSDKContext(cctx)
 	keeper := ch.keeper
 
 	msg := new(portMessage)
@@ -82,7 +80,7 @@ func (ch IBCModule) Receive(cctx context.Context, str string) (ret string, err e
 	switch msg.Method {
 	case "sendPacket":
 		seq, ok := keeper.GetNextSequenceSend(
-			ctx,
+			ctx.Context,
 			msg.Packet.SourcePort,
 			msg.Packet.SourceChannel,
 		)
@@ -93,7 +91,7 @@ func (ch IBCModule) Receive(cctx context.Context, str string) (ret string, err e
 		timeoutTimestamp := msg.Packet.TimeoutTimestamp
 		if msg.Packet.TimeoutHeight.IsZero() && msg.Packet.TimeoutTimestamp == 0 {
 			// Use the relative timeout if no absolute timeout is specifiied.
-			timeoutTimestamp = uint64(ctx.BlockTime().UnixNano()) + msg.RelativeTimeoutNs
+			timeoutTimestamp = uint64(ctx.Context.BlockTime().UnixNano()) + msg.RelativeTimeoutNs
 		}
 
 		packet := channeltypes.NewPacket(
@@ -102,7 +100,7 @@ func (ch IBCModule) Receive(cctx context.Context, str string) (ret string, err e
 			msg.Packet.DestinationPort, msg.Packet.DestinationChannel,
 			msg.Packet.TimeoutHeight, timeoutTimestamp,
 		)
-		err = keeper.SendPacket(ctx, packet)
+		err = keeper.SendPacket(ctx.Context, packet)
 		if err == nil {
 			bytes, err := json.Marshal(&packet)
 			if err == nil {
@@ -111,14 +109,14 @@ func (ch IBCModule) Receive(cctx context.Context, str string) (ret string, err e
 		}
 
 	case "receiveExecuted":
-		err = keeper.WriteAcknowledgement(ctx, msg.Packet, msg.Ack)
+		err = keeper.WriteAcknowledgement(ctx.Context, msg.Packet, msg.Ack)
 		if err == nil {
 			ret = "true"
 		}
 
 	case "startChannelOpenInit":
 		err = keeper.ChanOpenInit(
-			ctx, stringToOrder(msg.Order), msg.Hops,
+			ctx.Context, stringToOrder(msg.Order), msg.Hops,
 			msg.Packet.SourcePort,
 			msg.Packet.DestinationPort,
 			msg.Version,
@@ -128,19 +126,19 @@ func (ch IBCModule) Receive(cctx context.Context, str string) (ret string, err e
 		}
 
 	case "startChannelCloseInit":
-		err = keeper.ChanCloseInit(ctx, msg.Packet.SourcePort, msg.Packet.SourceChannel)
+		err = keeper.ChanCloseInit(ctx.Context, msg.Packet.SourcePort, msg.Packet.SourceChannel)
 		if err == nil {
 			ret = "true"
 		}
 
 	case "bindPort":
-		err = keeper.BindPort(ctx, msg.Packet.SourcePort)
+		err = keeper.BindPort(ctx.Context, msg.Packet.SourcePort)
 		if err == nil {
 			ret = "true"
 		}
 
 	case "timeoutExecuted":
-		err = keeper.TimeoutExecuted(ctx, msg.Packet)
+		err = keeper.TimeoutExecuted(ctx.Context, msg.Packet)
 		if err == nil {
 			ret = "true"
 		}
@@ -230,6 +228,7 @@ type channelOpenAckEvent struct {
 	Event                 string                    `json:"event"` // channelOpenAck
 	PortID                string                    `json:"portID"`
 	ChannelID             string                    `json:"channelID"`
+	CounterpartyChannelID string                    `json:"counterpartyChannelID"`
 	CounterpartyVersion   string                    `json:"counterpartyVersion"`
 	Counterparty          channeltypes.Counterparty `json:"counterparty"`
 	ConnectionHops        []string                  `json:"connectionHops"`
@@ -248,12 +247,12 @@ func (im IBCModule) OnChanOpenAck(
 	// returns an empty channel object that we can still use without crashing.
 	channel, _ := im.keeper.GetChannel(ctx, portID, channelID)
 
-	channel.Counterparty.ChannelId = counterpartyChannelID
 	event := channelOpenAckEvent{
 		Type:                  "IBC_EVENT",
 		Event:                 "channelOpenAck",
 		PortID:                portID,
 		ChannelID:             channelID,
+		CounterpartyChannelID: counterpartyChannelID,
 		CounterpartyVersion:   counterpartyVersion,
 		Counterparty:          channel.Counterparty,
 		ConnectionHops:        channel.ConnectionHops,

package/x/vibc/keeper/keeper.go

@@ -92,7 +92,13 @@ func (k Keeper) ChanOpenInit(ctx sdk.Context, order channeltypes.Order, connecti
 		return err
 	}
 
-	k.channelKeeper.WriteOpenInitChannel(ctx, portID, channelID, order, connectionHops, counterparty, version)
+	// We need to emit a channel event to notify the relayer.
+	ctx.EventManager().EmitEvents(sdk.Events{
+		sdk.NewEvent(
+			sdk.EventTypeMessage,
+			sdk.NewAttribute(sdk.AttributeKeyModule, channeltypes.AttributeValueCategory),
+		),
+	})
 	return nil
 }
 
@@ -151,6 +157,14 @@ func (k Keeper) ChanCloseInit(ctx sdk.Context, portID, channelID string) error {
 	if err != nil {
 		return err
 	}
+
+	// We need to emit a channel event to notify the relayer.
+	ctx.EventManager().EmitEvents(sdk.Events{
+		sdk.NewEvent(
+			sdk.EventTypeMessage,
+			sdk.NewAttribute(sdk.AttributeKeyModule, channeltypes.AttributeValueCategory),
+		),
+	})
 	return nil
 }
 

package/x/vibc/types/expected_keepers.go

@@ -16,8 +16,7 @@ type ChannelKeeper interface {
 	WriteAcknowledgement(ctx sdk.Context, channelCap *capability.Capability, packet ibcexported.PacketI, acknowledgement ibcexported.Acknowledgement) error
 	ChanOpenInit(ctx sdk.Context, order channel.Order, connectionHops []string, portID string,
 		portCap *capability.Capability, counterparty channel.Counterparty, version string) (string, *capability.Capability, error)
-	WriteOpenInitChannel(ctx sdk.Context, portID, channelID string, order channel.Order,
-		connectionHops []string, counterparty channel.Counterparty, version string)
+
 	ChanCloseInit(ctx sdk.Context, portID, channelID string, chanCap *capability.Capability) error
 	TimeoutExecuted(ctx sdk.Context, channelCap *capability.Capability, packet ibcexported.PacketI) error
 }

package/x/vstorage/keeper/grpc_query.go

@@ -2,14 +2,10 @@ package keeper
 
 import (
 	"context"
-	"encoding/json"
-	"fmt"
-	"strings"
 
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
 
-	"github.com/Agoric/agoric-sdk/golang/cosmos/x/vstorage/capdata"
 	"github.com/Agoric/agoric-sdk/golang/cosmos/x/vstorage/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 )
@@ -21,11 +17,6 @@ type Querier struct {
 
 var _ types.QueryServer = Querier{}
 
-// ===================================================================
-// /agoric.vstorage.Query/Data
-// ===================================================================
-
-// /agoric.vstorage.Query/Data returns data for a specified path.
 func (k Querier) Data(c context.Context, req *types.QueryDataRequest) (*types.QueryDataResponse, error) {
 	if req == nil {
 		return nil, status.Error(codes.InvalidArgument, "empty request")
@@ -39,218 +30,6 @@ func (k Querier) Data(c context.Context, req *types.QueryDataRequest) (*types.Qu
 	}, nil
 }
 
-// ===================================================================
-// /agoric.vstorage.Query/CapData
-// ===================================================================
-
-const (
-	// Media types.
-	JSONLines = "JSON Lines"
-
-	// CapData transformation formats.
-	FormatCapDataFlat = "flat"
-
-	// CapData remotable value formats.
-	FormatRemotableAsObject = "object"
-	FormatRemotableAsString = "string"
-)
-
-var capDataResponseMediaTypes = map[string]string{
-	JSONLines: JSONLines,
-	// Default to JSON Lines.
-	"": JSONLines,
-}
-var capDataTransformationFormats = map[string]string{
-	FormatCapDataFlat: FormatCapDataFlat,
-	// Default to no transformation.
-	"": "",
-}
-var capDataRemotableValueFormats = map[string]string{
-	FormatRemotableAsObject: FormatRemotableAsObject,
-	FormatRemotableAsString: FormatRemotableAsString,
-	// No default because both formats are lossy.
-}
-
-// flatten converts data into a flat structure in which each deep leaf entry is replaced with
-// a top-level entry having the same value but a key generated by joining the keys on its path
-// with separating dashes.
-// For example,
-// ```
-// { "contacts": [
-//
-//	{ "name": "Alice", "email": "a@example.com" },
-//	{ "name": "Bob", "email": "b@example.com" }
-//
-// ] }
-// ```
-// becomes
-// ```
-//
-//	{
-//	  "contacts-0-name": "Alice",
-//	  "contacts-0-email": "a@example.com",
-//	  "contacts-1-name": "Bob",
-//	  "contacts-1-email": "b@example.com"
-//	}
-//
-// ```
-// cf. https://github.com/Agoric/agoric-sdk/blob/6e5b422b80e47c4dac151404f43faea5ab41e9b0/scripts/get-flattened-publication.sh
-func flatten(input interface{}, output map[string]interface{}, key string, top bool) error {
-	// Act on the raw representation of a Remotable.
-	if remotable, ok := input.(*capdata.CapdataRemotable); ok {
-		var replacement interface{}
-		repr, err := capdata.JsonMarshal(remotable)
-		if err == nil {
-			err = json.Unmarshal(repr, &replacement)
-		}
-		if err != nil {
-			return err
-		}
-		input = replacement
-	}
-
-	childKeyPrefix := key
-	if !top {
-		childKeyPrefix = childKeyPrefix + "-"
-	}
-	if arr, ok := input.([]interface{}); ok {
-		for i, v := range arr {
-			if err := flatten(v, output, childKeyPrefix+fmt.Sprintf("%d", i), false); err != nil {
-				return err
-			}
-		}
-	} else if obj, ok := input.(map[string]interface{}); ok {
-		for k, v := range obj {
-			if err := flatten(v, output, childKeyPrefix+k, false); err != nil {
-				return err
-			}
-		}
-	} else {
-		if _, has := output[key]; has {
-			return fmt.Errorf("key conflict: %q", key)
-		}
-		output[key] = input
-	}
-	return nil
-}
-
-// capdataBigintToDigits represents a bigint as a string consisting of
-// an optional "-" followed by a sequence of digits with no extraneous zeroes
-// (e.g., "0" or "-40").
-func capdataBigintToDigits(bigint *capdata.CapdataBigint) interface{} {
-	return bigint.Normalized
-}
-
-// capdataRemotableToString represents a Remotable as a bracketed string
-// containing its alleged name and id from `slots`
-// (e.g., "[Alleged: IST brand <board007>]").
-func capdataRemotableToString(r *capdata.CapdataRemotable) interface{} {
-	iface := "Remotable"
-	if r.Iface != nil || *r.Iface != "" {
-		iface = *r.Iface
-	}
-	return fmt.Sprintf("[%s <%s>]", iface, r.Id)
-}
-
-// capdataRemotableToObject represents a Remotable as an object containing
-// its id from `slots` and its alleged name minus any "Alleged:" prefix
-// (e.g., `{ "id": "board007", "allegedName": "IST brand" }`).
-func capdataRemotableToObject(r *capdata.CapdataRemotable) interface{} {
-	iface := "Remotable"
-	if r.Iface != nil || *r.Iface != "" {
-		iface = *r.Iface
-		iface, _ = strings.CutPrefix(iface, "Alleged: ")
-	}
-	return map[string]interface{}{"id": r.Id, "allegedName": iface}
-}
-
-// /agoric.vstorage.Query/CapData returns data for a specified path,
-// interpreted as CapData in a StreamCell (auto-promoting isolated CapData
-// into a single-item StreamCell) and transformed as specified.
-func (k Querier) CapData(c context.Context, req *types.QueryCapDataRequest) (*types.QueryCapDataResponse, error) {
-	if req == nil {
-		return nil, status.Error(codes.InvalidArgument, "empty request")
-	}
-	ctx := sdk.UnwrapSDKContext(c)
-
-	valueTransformations := capdata.CapdataValueTransformations{
-		Bigint: capdataBigintToDigits,
-	}
-
-	// A response Value is "<prefix><separator-joined items><suffix>".
-	prefix, separator, suffix := "", "\n", ""
-
-	// Read options.
-	mediaType, ok := capDataResponseMediaTypes[req.MediaType]
-	if !ok {
-		return nil, status.Error(codes.InvalidArgument, "invalid media_type")
-	}
-	transformation, ok := capDataTransformationFormats[req.ItemFormat]
-	if !ok {
-		return nil, status.Error(codes.InvalidArgument, "invalid item_format")
-	}
-	switch remotableFormat, ok := capDataRemotableValueFormats[req.RemotableValueFormat]; {
-	case !ok:
-		return nil, status.Error(codes.InvalidArgument, "invalid remotable_value_format")
-	case remotableFormat == FormatRemotableAsObject:
-		valueTransformations.Remotable = capdataRemotableToObject
-	case remotableFormat == FormatRemotableAsString:
-		valueTransformations.Remotable = capdataRemotableToString
-	}
-
-	// Read data, auto-upgrading a standalone value to a single-value StreamCell.
-	entry := k.GetEntry(ctx, req.Path)
-	if !entry.HasValue() {
-		return nil, status.Error(codes.FailedPrecondition, "no data")
-	}
-	value := entry.StringValue()
-	var cell StreamCell
-	_ = json.Unmarshal([]byte(value), &cell)
-	if cell.BlockHeight == "" {
-		cell = StreamCell{Values: []string{value}}
-	}
-
-	// Format each StreamCell value.
-	responseItems := make([]string, len(cell.Values))
-	for i, capDataJson := range cell.Values {
-		item, err := capdata.DecodeSerializedCapdata(capDataJson, valueTransformations)
-		if err != nil {
-			return nil, status.Error(codes.FailedPrecondition, err.Error())
-		}
-		if transformation == FormatCapDataFlat {
-			flattened := map[string]interface{}{}
-			if err := flatten(item, flattened, "", true); err != nil {
-				return nil, status.Error(codes.Internal, err.Error())
-			}
-			// Replace the item, unless it was a scalar that "flattened" to `{ "": ... }`.
-			if _, singleton := flattened[""]; !singleton {
-				item = flattened
-			}
-		}
-		switch mediaType {
-		case JSONLines:
-			jsonText, err := capdata.JsonMarshal(item)
-			if err != nil {
-				return nil, status.Error(codes.Internal, err.Error())
-			}
-			responseItems[i] = string(jsonText)
-		}
-	}
-
-	return &types.QueryCapDataResponse{
-		BlockHeight: cell.BlockHeight,
-		Value:       prefix + strings.Join(responseItems, separator) + suffix,
-	}, nil
-}
-
-// ===================================================================
-// /agoric.vstorage.Query/Children
-// ===================================================================
-
-// /agoric.vstorage.Query/Children returns the list of path segments
-// that exist immediately underneath a specified path, including
-// those corresponding with "empty non-terminals" having children
-// but no data of their own.
 func (k Querier) Children(c context.Context, req *types.QueryChildrenRequest) (*types.QueryChildrenResponse, error) {
 	if req == nil {
 		return nil, status.Error(codes.InvalidArgument, "empty request")

package/x/vstorage/keeper/querier.go

@@ -1,6 +1,8 @@
 package keeper
 
 import (
+	"strings"
+
 	abci "github.com/tendermint/tendermint/abci/types"
 
 	"github.com/cosmos/cosmos-sdk/codec"
@@ -16,36 +18,14 @@ const (
 	QueryChildren = "children"
 )
 
-// getVstorageEntryPath validates that a request URL path represents a valid
-// entry path with no extra data, and returns the path of that vstorage entry.
-func getVstorageEntryPath(urlPathSegments []string) (string, error) {
-	if len(urlPathSegments) != 1 || types.ValidatePath(urlPathSegments[0]) != nil {
-		return "", sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "invalid vstorage entry path")
-	}
-	return urlPathSegments[0], nil
-}
-
-// NewQuerier returns the function for handling queries routed to this module.
-// It performs its own routing based on the first slash-separated URL path
-// segment (e.g., URL path `/data/foo.bar` is a request for the value associated
-// with vstorage path "foo.bar", and `/children/foo.bar` is a request for the
-// child path segments immediately underneath vstorage path "foo.bar" which may
-// be used to extend it to a vstorage path such as "foo.bar.baz").
+// NewQuerier is the module level router for state queries
 func NewQuerier(keeper Keeper, legacyQuerierCdc *codec.LegacyAmino) sdk.Querier {
-	return func(ctx sdk.Context, urlPathSegments []string, req abci.RequestQuery) (res []byte, err error) {
-		switch urlPathSegments[0] {
+	return func(ctx sdk.Context, path []string, req abci.RequestQuery) (res []byte, err error) {
+		switch path[0] {
 		case QueryData:
-			entryPath, entryPathErr := getVstorageEntryPath(urlPathSegments[1:])
-			if entryPathErr != nil {
-				return nil, entryPathErr
-			}
-			return queryData(ctx, entryPath, req, keeper, legacyQuerierCdc)
+			return queryData(ctx, strings.Join(path[1:], "/"), req, keeper, legacyQuerierCdc)
 		case QueryChildren:
-			entryPath, entryPathErr := getVstorageEntryPath(urlPathSegments[1:])
-			if entryPathErr != nil {
-				return nil, entryPathErr
-			}
-			return queryChildren(ctx, entryPath, req, keeper, legacyQuerierCdc)
+			return queryChildren(ctx, strings.Join(path[1:], "/"), req, keeper, legacyQuerierCdc)
 		default:
 			return nil, sdkerrors.Wrap(sdkerrors.ErrUnknownRequest, "unknown vstorage query endpoint")
 		}
@@ -56,12 +36,12 @@ func NewQuerier(keeper Keeper, legacyQuerierCdc *codec.LegacyAmino) sdk.Querier
 func queryData(ctx sdk.Context, path string, req abci.RequestQuery, keeper Keeper, legacyQuerierCdc *codec.LegacyAmino) (res []byte, err error) {
 	entry := keeper.GetEntry(ctx, path)
 	if !entry.HasValue() {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrNotFound, "no data for vstorage path")
+		return nil, sdkerrors.Wrap(sdkerrors.ErrUnknownRequest, "could not get vstorage path")
 	}
 
-	bz, marshalErr := codec.MarshalJSONIndent(legacyQuerierCdc, types.Data{Value: entry.StringValue()})
-	if marshalErr != nil {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrJSONMarshal, marshalErr.Error())
+	bz, err2 := codec.MarshalJSONIndent(legacyQuerierCdc, types.Data{Value: entry.StringValue()})
+	if err2 != nil {
+		return nil, sdkerrors.Wrap(sdkerrors.ErrJSONMarshal, err2.Error())
 	}
 
 	return bz, nil

package/x/vstorage/types/path_keys.go

@@ -7,17 +7,9 @@ import (
 	"strings"
 )
 
-// - A "path" is a sequence of zero or more dot-separated nonempty segments
-// using a restricted alphabet of ASCII alphanumerics plus underscore and dash,
-// consistent with packages/internal/src/lib-chainStorage.js but not currently
-// enforcing a length restriction on path segments.
-// So `""`, `"foo"`, and `"foo.bar__baz.qux--quux"` are paths but `"."`,
-// `"foo/bar"`, `"fo\to"`, and `"foö"` are not.
-// This alphabet might be expanded in the future, but such expansion SHOULD NOT
-// include control characters (including those that are not ASCII, such as
-// U+202E RIGHT-TO-LEFT OVERRIDE), slash `/` (which separates ABCI request path
-// segments in e.g. `custom/vstorage/data/foo`), or backslash `\` (which should
-// be reserved for adding escape sequences).
+// - A "path" is a sequence of zero or more dot-separated nonempty strings of
+// 7-bit non-nul, non-dot ASCII characters. So `""`, `"foo"`, and
+// `"foo.bar.baz"` are paths but `"."`, "foo.", and "fo\0o" are not.
 //
 // - An encoded key for a path is the path prefixed with its length (in ASCII
 // digits), separated by nul, followed by the path with dots replaced with nul.
@@ -50,26 +42,22 @@ func EncodedKeyToPath(key []byte) string {
 	return string(pathBytes)
 }
 
-var pathSegmentPattern = `[a-zA-Z0-9_-]+`
-var pathSeparatorPattern = `\` + PathSeparator
-var pathPattern = fmt.Sprintf(`^$|^%[1]s(%[2]s%[1]s)*$`, pathSegmentPattern, pathSeparatorPattern)
-var pathMatcher = regexp.MustCompile(pathPattern)
+var pathPattern = regexp.MustCompile(`[-a-zA-Z0-9_` + PathSeparator + `]*`)
 
 func ValidatePath(path string) error {
-	if pathMatcher.MatchString(path) {
-		return nil
+	if !pathPattern.MatchString(path) {
+		return fmt.Errorf("path %q contains invalid characters", path)
+	}
+	if strings.Contains(path, PathSeparator+PathSeparator) {
+		return fmt.Errorf("path %q contains doubled separators", path)
 	}
-	// Rescan the string to give a useful error message.
 	if strings.HasPrefix(path, PathSeparator) {
 		return fmt.Errorf("path %q starts with separator", path)
 	}
 	if strings.HasSuffix(path, PathSeparator) {
 		return fmt.Errorf("path %q ends with separator", path)
 	}
-	if strings.Contains(path, PathSeparator+PathSeparator) {
-		return fmt.Errorf("path %q contains doubled separators", path)
-	}
-	return fmt.Errorf("path %q contains invalid characters", path)
+	return nil
 }
 
 // PathToEncodedKey converts a path to a byte slice key

package/x/vstorage/types/path_keys_test.go

@@ -2,106 +2,40 @@ package types
 
 import (
 	"bytes"
-	"fmt"
-	"strings"
 	"testing"
 )
 
 func Test_Key_Encoding(t *testing.T) {
 	tests := []struct {
-		name        string
-		path        string
-		key         []byte
-		errContains string
+		name     string
+		childStr string
+		key      []byte
 	}{
 		{
-			name: "empty path",
-			path: "",
-			key:  []byte("0\x00"),
+			name:     "empty key is prefixed",
+			childStr: "",
+			key:      []byte("0\x00"),
 		},
 		{
-			name: "single-segment path",
-			path: "some",
-			key:  []byte("1\x00some"),
+			name:     "some key string",
+			childStr: "some",
+			key:      []byte("1\x00some"),
 		},
 		{
-			name: "multi-segment path",
-			path: "some.child.grandchild",
-			key:  []byte("3\x00some\x00child\x00grandchild"),
-		},
-		{
-			name: "non-letters",
-			path: "-_0_-",
-			key:  []byte("1\x00-_0_-"),
-		},
-		{
-			name:        "lone dot",
-			path:        ".",
-			errContains: "starts with separator",
-		},
-		{
-			name:        "starts with dot",
-			path:        ".foo",
-			errContains: "starts with separator",
-		},
-		{
-			name:        "ends with dot",
-			path:        "foo.",
-			errContains: "ends with separator",
-		},
-		{
-			name:        "empty path segment",
-			path:        "foo..bar",
-			errContains: "doubled separators",
-		},
-		{
-			name:        "invalid path character U+0000 NUL",
-			path:        "foo\x00bar",
-			errContains: "invalid character",
-		},
-		{
-			name:        "invalid path character U+002F SOLIDUS",
-			path:        "foo/bar",
-			errContains: "invalid character",
-		},
-		{
-			name:        "invalid path character U+005C REVERSE SOLIDUS",
-			path:        "foo\\bar",
-			errContains: "invalid character",
-		},
-		{
-			name:        "invalid path character U+007C VERTICAL LINE",
-			path:        "foo|bar",
-			errContains: "invalid character",
+			name:     "dot-separated",
+			childStr: "some.child.grandchild",
+			key:      []byte("3\x00some\x00child\x00grandchild"),
 		},
 	}
 
 	for _, tt := range tests {
-		if tt.key != nil {
-			t.Run(tt.name, func(t *testing.T) {
-				if key := PathToEncodedKey(tt.path); !bytes.Equal(key, tt.key) {
-					t.Errorf("pathToKey(%q) = []byte(%q), want []byte(%q)", tt.path, key, tt.key)
-				}
-				if path := EncodedKeyToPath(tt.key); path != tt.path {
-					t.Errorf("keyToPath([]byte(%q)) = %q, want %q", tt.key, path, tt.path)
-				}
-			})
-			continue
-		}
-		expect := tt.errContains
 		t.Run(tt.name, func(t *testing.T) {
-			var key []byte
-			defer func() {
-				if err := recover(); err != nil {
-					errStr := fmt.Sprintf("%v", err)
-					if !strings.Contains(errStr, expect) {
-						t.Errorf("pathToKey(%q) = error %q, want error %v", tt.path, errStr, expect)
-					}
-				} else {
-					t.Errorf("pathToKey(%q) = []byte(%q), want error %v", tt.path, key, expect)
-				}
-			}()
-			key = PathToEncodedKey(tt.path)
+			if key := PathToEncodedKey(tt.childStr); !bytes.Equal(key, tt.key) {
+				t.Errorf("pathToKey(%q) = %v, want %v", tt.childStr, key, tt.key)
+			}
+			if childStr := EncodedKeyToPath(tt.key); childStr != tt.childStr {
+				t.Errorf("keyToString(%v) = %q, want %q", tt.key, childStr, tt.childStr)
+			}
 		})
 	}
 }