@agoric/cosmos 0.34.2-dev-7cc5def.0 → 0.35.0-u11.0

package/x/swingset/module.go

@@ -80,18 +80,22 @@ func (AppModuleBasic) GetTxCmd() *cobra.Command {
 
 type AppModule struct {
 	AppModuleBasic
-	keeper                 Keeper
-	setBootstrapNeeded     func()
-	ensureControllerInited func(sdk.Context)
+	keeper                   Keeper
+	swingStoreExportsHandler *SwingStoreExportsHandler
+	setBootstrapNeeded       func()
+	ensureControllerInited   func(sdk.Context)
+	swingStoreExportDir      string
 }
 
 // NewAppModule creates a new AppModule Object
-func NewAppModule(k Keeper, setBootstrapNeeded func(), ensureControllerInited func(sdk.Context)) AppModule {
+func NewAppModule(k Keeper, swingStoreExportsHandler *SwingStoreExportsHandler, setBootstrapNeeded func(), ensureControllerInited func(sdk.Context), swingStoreExportDir string) AppModule {
 	am := AppModule{
-		AppModuleBasic:         AppModuleBasic{},
-		keeper:                 k,
-		setBootstrapNeeded:     setBootstrapNeeded,
-		ensureControllerInited: ensureControllerInited,
+		AppModuleBasic:           AppModuleBasic{},
+		keeper:                   k,
+		swingStoreExportsHandler: swingStoreExportsHandler,
+		setBootstrapNeeded:       setBootstrapNeeded,
+		ensureControllerInited:   ensureControllerInited,
+		swingStoreExportDir:      swingStoreExportDir,
 	}
 	return am
 }
@@ -150,10 +154,17 @@ func (am AppModule) EndBlock(ctx sdk.Context, req abci.RequestEndBlock) []abci.V
 	return []abci.ValidatorUpdate{}
 }
 
+func (am AppModule) checkSwingStoreExportSetup() {
+	if am.swingStoreExportDir == "" {
+		panic(fmt.Errorf("SwingStore export dir not set"))
+	}
+}
+
 func (am AppModule) InitGenesis(ctx sdk.Context, cdc codec.JSONCodec, data json.RawMessage) []abci.ValidatorUpdate {
 	var genesisState types.GenesisState
 	cdc.MustUnmarshalJSON(data, &genesisState)
-	bootstrapNeeded := InitGenesis(ctx, am.keeper, &genesisState)
+	am.checkSwingStoreExportSetup()
+	bootstrapNeeded := InitGenesis(ctx, am.keeper, am.swingStoreExportsHandler, am.swingStoreExportDir, &genesisState)
 	if bootstrapNeeded {
 		am.setBootstrapNeeded()
 	}
@@ -161,6 +172,7 @@ func (am AppModule) InitGenesis(ctx sdk.Context, cdc codec.JSONCodec, data json.
 }
 
 func (am AppModule) ExportGenesis(ctx sdk.Context, cdc codec.JSONCodec) json.RawMessage {
-	gs := ExportGenesis(ctx, am.keeper)
+	am.checkSwingStoreExportSetup()
+	gs := ExportGenesis(ctx, am.keeper, am.swingStoreExportsHandler, am.swingStoreExportDir)
 	return cdc.MustMarshalJSON(gs)
 }

package/x/swingset/types/default-params.go

@@ -50,7 +50,7 @@ var (
 	DefaultBeansPerMinFeeDebit = DefaultBeansPerFeeUnit.Quo(sdk.NewUint(5))      // $0.2
 	DefaultBeansPerStorageByte = DefaultBeansPerFeeUnit.Quo(sdk.NewUint(500))    // $0.002
 
-	DefaultBootstrapVatConfig = "@agoric/vm-config/decentral-core-config.json"
+	DefaultBootstrapVatConfig = "@agoric/vats/decentral-core-config.json"
 
 	DefaultPowerFlagFees = []PowerFlagFee{
 		NewPowerFlagFee("SMART_WALLET", sdk.NewCoins(sdk.NewInt64Coin("ubld", 10_000_000))),

package/x/swingset/types/msgs.pb.go

@@ -433,7 +433,7 @@ type MsgInstallBundle struct {
 	Submitter github_com_cosmos_cosmos_sdk_types.AccAddress `protobuf:"bytes,2,opt,name=submitter,proto3,casttype=github.com/cosmos/cosmos-sdk/types.AccAddress" json:"submitter" yaml:"submitter"`
 	// Either bundle or compressed_bundle will be set.
 	// Default compression algorithm is gzip.
-	CompressedBundle []byte `protobuf:"bytes,3,opt,name=compressed_bundle,json=compressedBundle,proto3" json:"compressedBundle" yaml:"compressedBundle"`
+	CompressedBundle []byte `protobuf:"bytes,3,opt,name=compressed_bundle,json=compressedBundle,proto3" json:"compressedBundle" yaml:"bcompressedBndle"`
 	// Size in bytes of uncompression of compressed_bundle.
 	UncompressedSize int64 `protobuf:"varint,4,opt,name=uncompressed_size,json=uncompressedSize,proto3" json:"uncompressedSize"`
 }
@@ -553,7 +553,7 @@ func init() {
 func init() { proto.RegisterFile("agoric/swingset/msgs.proto", fileDescriptor_788baa062b181a57) }
 
 var fileDescriptor_788baa062b181a57 = []byte{
-	// 788 bytes of a gzipped FileDescriptorProto
+	// 789 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x56, 0xcf, 0x6f, 0xe3, 0x44,
 	0x14, 0x8e, 0xe3, 0x50, 0x36, 0xaf, 0xd9, 0x6d, 0x63, 0x95, 0xad, 0xd7, 0x0b, 0x99, 0xac, 0xa5,
 	0x15, 0x01, 0xd4, 0x44, 0xb0, 0xb7, 0xed, 0x29, 0x16, 0x42, 0x5a, 0xa4, 0xa0, 0xc5, 0x2b, 0x84,
@@ -590,20 +590,20 @@ var fileDescriptor_788baa062b181a57 = []byte{
 	0x01, 0x8d, 0x2d, 0xcf, 0x33, 0x66, 0xc1, 0xc4, 0xc3, 0xca, 0x0b, 0xd8, 0x1a, 0xf3, 0x7f, 0xf9,
 	0xe9, 0x3c, 0x4d, 0x18, 0xca, 0x91, 0x94, 0xa1, 0x87, 0xc2, 0x9e, 0x88, 0x75, 0x33, 0x27, 0x96,
 	0x57, 0x56, 0xbf, 0x87, 0x95, 0x29, 0xdf, 0x40, 0xdb, 0x26, 0x7e, 0x98, 0xc1, 0x78, 0x72, 0x9c,
-	0x3b, 0x96, 0x79, 0xe7, 0x41, 0xc2, 0xd0, 0x6e, 0x45, 0x1a, 0x85, 0xf7, 0x7d, 0x61, 0x60, 0x95,
-	0xd1, 0xcd, 0x35, 0xb1, 0x32, 0x84, 0xf6, 0x2c, 0x58, 0xa8, 0x4f, 0xdd, 0x4b, 0xcc, 0x4f, 0x4c,
-	0x36, 0xf6, 0xb2, 0xea, 0x8b, 0xe4, 0x1b, 0xf7, 0x12, 0x9b, 0x6b, 0x88, 0xae, 0x81, 0xba, 0xba,
-	0xb7, 0xc5, 0xc6, 0x7f, 0x72, 0x2d, 0x83, 0x3c, 0xa2, 0x8e, 0xf2, 0x2d, 0x3c, 0x5c, 0xde, 0xfc,
-	0x67, 0xfd, 0x95, 0xd7, 0x40, 0x7f, 0xb5, 0x86, 0xf6, 0xc1, 0xad, 0x92, 0xa2, 0x8d, 0x72, 0x02,
-	0x8f, 0x56, 0x5e, 0x14, 0xfa, 0xa6, 0xe4, 0x65, 0x8d, 0xf6, 0xe1, 0xed, 0x9a, 0xb2, 0xc3, 0x11,
-	0xb4, 0x96, 0x1e, 0xa6, 0xdd, 0x4d, 0xb9, 0x8b, 0x0a, 0xad, 0x77, 0x9b, 0xa2, 0xac, 0xed, 0x42,
-	0x7b, 0xfd, 0xc9, 0xf7, 0xfc, 0x9f, 0xd3, 0x17, 0x64, 0xda, 0xc1, 0x7f, 0x92, 0x95, 0xad, 0xbe,
-	0x84, 0x66, 0xf5, 0x80, 0x7a, 0x6f, 0x53, 0x6e, 0x49, 0x6b, 0xcf, 0xff, 0x95, 0x2e, 0x4a, 0x1a,
-	0x5f, 0xfd, 0x36, 0xef, 0x48, 0x57, 0xf3, 0x8e, 0x74, 0x3d, 0xef, 0x48, 0x3f, 0xde, 0x74, 0x6a,
-	0x57, 0x37, 0x9d, 0xda, 0xef, 0x37, 0x9d, 0xda, 0xd1, 0xe1, 0xc2, 0xcc, 0x0f, 0xc5, 0x07, 0x81,
-	0xa8, 0xc8, 0x67, 0xde, 0x21, 0x9e, 0x15, 0x38, 0xc5, 0x65, 0xf8, 0xbe, 0xfa, 0x56, 0xe0, 0x97,
-	0x61, 0xbc, 0xc5, 0x3f, 0x03, 0x5e, 0xfc, 0x1d, 0x00, 0x00, 0xff, 0xff, 0x51, 0x66, 0x1b, 0xd5,
-	0x4b, 0x08, 0x00, 0x00,
+	0x3b, 0x96, 0x79, 0xe7, 0x41, 0xc2, 0xd0, 0x6e, 0x45, 0x1a, 0x85, 0xf7, 0xfd, 0xdc, 0xfb, 0x02,
+	0x25, 0x56, 0xb1, 0x26, 0x56, 0x86, 0xd0, 0x9e, 0x05, 0x0b, 0xf5, 0xa9, 0x7b, 0x89, 0xf9, 0x89,
+	0xc9, 0xc6, 0x5e, 0x56, 0x7d, 0x91, 0x7c, 0xe3, 0x5e, 0x62, 0x73, 0x0d, 0xd1, 0x35, 0x50, 0x57,
+	0xf7, 0xb6, 0xd8, 0xf8, 0x4f, 0xae, 0x65, 0x90, 0x47, 0xd4, 0x51, 0xbe, 0x85, 0x87, 0xcb, 0x9b,
+	0xff, 0xac, 0xbf, 0xf2, 0x1a, 0xe8, 0xaf, 0xd6, 0xd0, 0x3e, 0xb8, 0x55, 0x52, 0xb4, 0x51, 0x4e,
+	0xe0, 0xd1, 0xca, 0x8b, 0x42, 0xdf, 0x94, 0xbc, 0xac, 0xd1, 0x3e, 0xbc, 0x5d, 0x53, 0x76, 0x38,
+	0x82, 0xd6, 0xd2, 0xc3, 0xb4, 0xbb, 0x29, 0x77, 0x51, 0xa1, 0xf5, 0x6e, 0x53, 0x94, 0xb5, 0x5d,
+	0x68, 0xaf, 0x3f, 0xf9, 0x9e, 0xff, 0x73, 0xfa, 0x82, 0x4c, 0x3b, 0xf8, 0x4f, 0xb2, 0xb2, 0xd5,
+	0x97, 0xd0, 0xac, 0x1e, 0x50, 0xef, 0x6d, 0xca, 0x2d, 0x69, 0xed, 0xf9, 0xbf, 0xd2, 0x45, 0x49,
+	0xe3, 0xab, 0xdf, 0xe6, 0x1d, 0xe9, 0x6a, 0xde, 0x91, 0xae, 0xe7, 0x1d, 0xe9, 0xc7, 0x9b, 0x4e,
+	0xed, 0xea, 0xa6, 0x53, 0xfb, 0xfd, 0xa6, 0x53, 0x3b, 0x3a, 0x5c, 0x98, 0xf9, 0xa1, 0xf8, 0x20,
+	0x10, 0x15, 0xf9, 0xcc, 0x3b, 0xc4, 0xb3, 0x02, 0xa7, 0xb8, 0x0c, 0xdf, 0x57, 0xdf, 0x0a, 0xfc,
+	0x32, 0x8c, 0xb7, 0xf8, 0x67, 0xc0, 0x8b, 0xbf, 0x03, 0x00, 0x00, 0xff, 0xff, 0x99, 0x11, 0x18,
+	0xbe, 0x4b, 0x08, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.

package/x/vibc/ibc.go

@@ -228,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"`
@@ -246,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")