@agoric/cosmos 0.35.0-u11wf.0 → 0.35.0-u13.0

package/x/vibc/ibc.go

@@ -7,11 +7,11 @@ import (
 	"github.com/Agoric/agoric-sdk/golang/cosmos/vm"
 	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 	capability "github.com/cosmos/cosmos-sdk/x/capability/types"
-	channeltypes "github.com/cosmos/ibc-go/v3/modules/core/04-channel/types"
-	porttypes "github.com/cosmos/ibc-go/v3/modules/core/05-port/types"
-	host "github.com/cosmos/ibc-go/v3/modules/core/24-host"
+	channeltypes "github.com/cosmos/ibc-go/v4/modules/core/04-channel/types"
+	porttypes "github.com/cosmos/ibc-go/v4/modules/core/05-port/types"
+	host "github.com/cosmos/ibc-go/v4/modules/core/24-host"
 
-	"github.com/cosmos/ibc-go/v3/modules/core/exported"
+	"github.com/cosmos/ibc-go/v4/modules/core/exported"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
 )
@@ -167,8 +167,8 @@ func (im IBCModule) OnChanOpenInit(
 	channelCap *capability.Capability,
 	counterparty channeltypes.Counterparty,
 	version string,
-) error {
-	return sdkerrors.Wrap(
+) (string, error) {
+	return "", sdkerrors.Wrap(
 		channeltypes.ErrChannelNotFound,
 		fmt.Sprintf("vibc does not allow synthetic channelOpenInit for port %s", portID),
 	)
@@ -224,16 +224,15 @@ func (im IBCModule) OnChanOpenTry(
 }
 
 type channelOpenAckEvent struct {
-	Type                  string                    `json:"type"`  // IBC
-	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"`
-	BlockHeight           int64                     `json:"blockHeight"`
-	BlockTime             int64                     `json:"blockTime"`
+	Type                string                    `json:"type"`  // IBC
+	Event               string                    `json:"event"` // channelOpenAck
+	PortID              string                    `json:"portID"`
+	ChannelID           string                    `json:"channelID"`
+	CounterpartyVersion string                    `json:"counterpartyVersion"`
+	Counterparty        channeltypes.Counterparty `json:"counterparty"`
+	ConnectionHops      []string                  `json:"connectionHops"`
+	BlockHeight         int64                     `json:"blockHeight"`
+	BlockTime           int64                     `json:"blockTime"`
 }
 
 func (im IBCModule) OnChanOpenAck(
@@ -247,17 +246,17 @@ 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,
-		BlockHeight:           ctx.BlockHeight(),
-		BlockTime:             ctx.BlockTime().Unix(),
+		Type:                "IBC_EVENT",
+		Event:               "channelOpenAck",
+		PortID:              portID,
+		ChannelID:           channelID,
+		CounterpartyVersion: counterpartyVersion,
+		Counterparty:        channel.Counterparty,
+		ConnectionHops:      channel.ConnectionHops,
+		BlockHeight:         ctx.BlockHeight(),
+		BlockTime:           ctx.BlockTime().Unix(),
 	}
 
 	return im.PushAction(ctx, event)
@@ -374,7 +373,7 @@ func (im IBCModule) OnRecvPacket(
 
 	err := im.PushAction(ctx, event)
 	if err != nil {
-		return channeltypes.NewErrorAcknowledgement(err.Error())
+		return channeltypes.NewErrorAcknowledgement(err)
 	}
 
 	return nil

package/x/vibc/keeper/keeper.go

@@ -9,10 +9,10 @@ import (
 	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 	capabilitykeeper "github.com/cosmos/cosmos-sdk/x/capability/keeper"
 	capability "github.com/cosmos/cosmos-sdk/x/capability/types"
-	channeltypes "github.com/cosmos/ibc-go/v3/modules/core/04-channel/types"
-	porttypes "github.com/cosmos/ibc-go/v3/modules/core/05-port/types"
-	host "github.com/cosmos/ibc-go/v3/modules/core/24-host"
-	ibcexported "github.com/cosmos/ibc-go/v3/modules/core/exported"
+	channeltypes "github.com/cosmos/ibc-go/v4/modules/core/04-channel/types"
+	porttypes "github.com/cosmos/ibc-go/v4/modules/core/05-port/types"
+	host "github.com/cosmos/ibc-go/v4/modules/core/24-host"
+	ibcexported "github.com/cosmos/ibc-go/v4/modules/core/exported"
 
 	bankkeeper "github.com/cosmos/cosmos-sdk/x/bank/keeper"
 
@@ -92,13 +92,7 @@ func (k Keeper) ChanOpenInit(ctx sdk.Context, order channeltypes.Order, connecti
 		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),
-		),
-	})
+	k.channelKeeper.WriteOpenInitChannel(ctx, portID, channelID, order, connectionHops, counterparty, version)
 	return nil
 }
 
@@ -157,14 +151,6 @@ 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

@@ -3,9 +3,9 @@ package types
 import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	capability "github.com/cosmos/cosmos-sdk/x/capability/types"
-	connection "github.com/cosmos/ibc-go/v3/modules/core/03-connection/types"
-	channel "github.com/cosmos/ibc-go/v3/modules/core/04-channel/types"
-	ibcexported "github.com/cosmos/ibc-go/v3/modules/core/exported"
+	connection "github.com/cosmos/ibc-go/v4/modules/core/03-connection/types"
+	channel "github.com/cosmos/ibc-go/v4/modules/core/04-channel/types"
+	ibcexported "github.com/cosmos/ibc-go/v4/modules/core/exported"
 )
 
 // ChannelKeeper defines the expected IBC channel keeper
@@ -16,7 +16,8 @@ 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/vibc/types/msgs.go

@@ -4,7 +4,7 @@ import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 
-	chanTypes "github.com/cosmos/ibc-go/v3/modules/core/04-channel/types"
+	chanTypes "github.com/cosmos/ibc-go/v4/modules/core/04-channel/types"
 )
 
 const RouterKey = ModuleName // this was defined in your key.go file

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

@@ -7,7 +7,7 @@ import (
 	context "context"
 	fmt "fmt"
 	github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
-	types "github.com/cosmos/ibc-go/v3/modules/core/04-channel/types"
+	types "github.com/cosmos/ibc-go/v4/modules/core/04-channel/types"
 	_ "github.com/gogo/protobuf/gogoproto"
 	grpc1 "github.com/gogo/protobuf/grpc"
 	proto "github.com/gogo/protobuf/proto"

package/x/vstorage/keeper/querier.go

@@ -1,8 +1,6 @@
 package keeper
 
 import (
-	"strings"
-
 	abci "github.com/tendermint/tendermint/abci/types"
 
 	"github.com/cosmos/cosmos-sdk/codec"
@@ -18,14 +16,36 @@ const (
 	QueryChildren = "children"
 )
 
-// NewQuerier is the module level router for state queries
+// 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").
 func NewQuerier(keeper Keeper, legacyQuerierCdc *codec.LegacyAmino) sdk.Querier {
-	return func(ctx sdk.Context, path []string, req abci.RequestQuery) (res []byte, err error) {
-		switch path[0] {
+	return func(ctx sdk.Context, urlPathSegments []string, req abci.RequestQuery) (res []byte, err error) {
+		switch urlPathSegments[0] {
 		case QueryData:
-			return queryData(ctx, strings.Join(path[1:], "/"), req, keeper, legacyQuerierCdc)
+			entryPath, entryPathErr := getVstorageEntryPath(urlPathSegments[1:])
+			if entryPathErr != nil {
+				return nil, entryPathErr
+			}
+			return queryData(ctx, entryPath, req, keeper, legacyQuerierCdc)
 		case QueryChildren:
-			return queryChildren(ctx, strings.Join(path[1:], "/"), req, keeper, legacyQuerierCdc)
+			entryPath, entryPathErr := getVstorageEntryPath(urlPathSegments[1:])
+			if entryPathErr != nil {
+				return nil, entryPathErr
+			}
+			return queryChildren(ctx, entryPath, req, keeper, legacyQuerierCdc)
 		default:
 			return nil, sdkerrors.Wrap(sdkerrors.ErrUnknownRequest, "unknown vstorage query endpoint")
 		}
@@ -36,12 +56,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.ErrUnknownRequest, "could not get vstorage path")
+		return nil, sdkerrors.Wrap(sdkerrors.ErrNotFound, "no data for vstorage path")
 	}
 
-	bz, err2 := codec.MarshalJSONIndent(legacyQuerierCdc, types.Data{Value: entry.StringValue()})
-	if err2 != nil {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrJSONMarshal, err2.Error())
+	bz, marshalErr := codec.MarshalJSONIndent(legacyQuerierCdc, types.Data{Value: entry.StringValue()})
+	if marshalErr != nil {
+		return nil, sdkerrors.Wrap(sdkerrors.ErrJSONMarshal, marshalErr.Error())
 	}
 
 	return bz, nil

package/x/vstorage/keeper/querier_test.go

@@ -0,0 +1,112 @@
+package keeper
+
+import (
+	"bytes"
+	"testing"
+
+	agoric "github.com/Agoric/agoric-sdk/golang/cosmos/types"
+
+	abci "github.com/tendermint/tendermint/abci/types"
+
+	"github.com/cosmos/cosmos-sdk/codec"
+	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+)
+
+func TestQuerier(t *testing.T) {
+	testKit := makeTestKit()
+	ctx, keeper := testKit.ctx, testKit.vstorageKeeper
+	legacyQuerierCdc := codec.NewAminoCodec(codec.NewLegacyAmino())
+	querier := NewQuerier(keeper, legacyQuerierCdc.LegacyAmino)
+
+	// Populate mock data
+	keeper.SetStorage(ctx, agoric.NewKVEntry("foo.bar", "42"))
+	keeper.SetStorage(ctx, agoric.NewKVEntry("foo.baz", "hello"))
+
+	type testCase struct {
+		label    string
+		path     []string
+		expected []byte
+		err      *sdkerrors.Error
+	}
+	testCases := []testCase{}
+
+	// Test invalid endpoint
+	testCases = append(testCases, []testCase{
+		{label: "invalid endpoint",
+			path: []string{"foo"},
+			err:  sdkerrors.ErrUnknownRequest,
+		},
+	}...)
+
+	// Test invalid arguments to valid data and children endpoints
+	for _, endpoint := range []string{"data", "children"} {
+		testCases = append(testCases, []testCase{
+			{label: endpoint + ": no entry path",
+				path: []string{endpoint},
+				err:  sdkerrors.ErrInvalidRequest,
+			},
+			{label: endpoint + ": too many segments",
+				path: []string{endpoint, "foo", "bar"},
+				err:  sdkerrors.ErrInvalidRequest,
+			},
+			{label: endpoint + ": invalid path",
+				path: []string{endpoint, ".", ""},
+				err:  sdkerrors.ErrInvalidRequest,
+			},
+		}...)
+	}
+
+	// Test data endpoint with valid vstorage path
+	testCases = append(testCases, []testCase{
+		{label: "data: non-existent path",
+			path: []string{"data", "bar"},
+			// DO NOT CHANGE
+			// The UI and CLI check for the specific cosmos-sdk error code & codespace
+			err: sdkerrors.ErrNotFound,
+		},
+		{label: "data: path with no data",
+			path: []string{"data", "foo"},
+			// DO NOT CHANGE
+			// The UI and CLI check for the specific cosmos-sdk error code & codespace
+			err: sdkerrors.ErrNotFound,
+		},
+		{label: "data: path with data",
+			path:     []string{"data", "foo.bar"},
+			expected: []byte("{\n  \"value\": \"42\"\n}"),
+		},
+	}...)
+
+	// Ensure stability of cosmos-sdk error codes
+	if codespace, code, _ := sdkerrors.ABCIInfo(sdkerrors.ErrNotFound, true); codespace != "sdk" || code != 38 {
+		t.Errorf("cosmos-sdk ErrNotFound has codespace %s, code %d, expected sdk/38", codespace, code)
+	}
+
+	// Test children endpoint with valid vstorage path
+	testCases = append(testCases, []testCase{
+		{label: "children: non-existent path",
+			path:     []string{"children", "bar"},
+			expected: []byte("{\n  \"children\": []\n}"),
+		},
+		{label: "children: path with no children",
+			path:     []string{"children", "foo.bar"},
+			expected: []byte("{\n  \"children\": []\n}"),
+		},
+		{label: "children: path with children",
+			path:     []string{"children", "foo"},
+			expected: []byte("{\n  \"children\": [\n    \"bar\",\n    \"baz\"\n  ]\n}"),
+		},
+	}...)
+
+	for _, desc := range testCases {
+		res, err := querier(ctx, desc.path, abci.RequestQuery{})
+		if desc.err != nil {
+			if err == nil {
+				t.Errorf("%s: got no error, want error %q", desc.label, *desc.err)
+			} else if codespace, code, _ := sdkerrors.ABCIInfo(err, true); codespace != desc.err.Codespace() || code != desc.err.ABCICode() {
+				t.Errorf("%s: got error %v, want error %q", desc.label, err, *desc.err)
+			}
+		} else if !bytes.Equal(res, desc.expected) {
+			t.Errorf("%s: wrong result: %#v, expected %#v", desc.label, string(res), string(desc.expected))
+		}
+	}
+}

package/x/vstorage/types/path_keys.go

@@ -7,9 +7,17 @@ import (
 	"strings"
 )
 
-// - 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.
+// - 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).
 //
 // - 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.
@@ -42,22 +50,26 @@ func EncodedKeyToPath(key []byte) string {
 	return string(pathBytes)
 }
 
-var pathPattern = regexp.MustCompile(`[-a-zA-Z0-9_` + PathSeparator + `]*`)
+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)
 
 func ValidatePath(path string) error {
-	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)
+	if pathMatcher.MatchString(path) {
+		return nil
 	}
+	// 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)
 	}
-	return nil
+	if strings.Contains(path, PathSeparator+PathSeparator) {
+		return fmt.Errorf("path %q contains doubled separators", path)
+	}
+	return fmt.Errorf("path %q contains invalid characters", path)
 }
 
 // PathToEncodedKey converts a path to a byte slice key

package/x/vstorage/types/path_keys_test.go

@@ -2,40 +2,106 @@ package types
 
 import (
 	"bytes"
+	"fmt"
+	"strings"
 	"testing"
 )
 
 func Test_Key_Encoding(t *testing.T) {
 	tests := []struct {
-		name     string
-		childStr string
-		key      []byte
+		name        string
+		path        string
+		key         []byte
+		errContains string
 	}{
 		{
-			name:     "empty key is prefixed",
-			childStr: "",
-			key:      []byte("0\x00"),
+			name: "empty path",
+			path: "",
+			key:  []byte("0\x00"),
 		},
 		{
-			name:     "some key string",
-			childStr: "some",
-			key:      []byte("1\x00some"),
+			name: "single-segment path",
+			path: "some",
+			key:  []byte("1\x00some"),
 		},
 		{
-			name:     "dot-separated",
-			childStr: "some.child.grandchild",
-			key:      []byte("3\x00some\x00child\x00grandchild"),
+			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",
 		},
 	}
 
 	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) {
-			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)
-			}
+			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)
 		})
 	}
 }

package/app/const.go

@@ -1,6 +0,0 @@
-package gaia
-
-const (
-	upgradeName     = "agoric-upgrade-11"
-	upgradeNameTest = "agorictest-upgrade-11"
-)

package/x/swingset/legacy/v32/params.go

@@ -1,37 +0,0 @@
-package v32
-
-import (
-	"fmt"
-
-	"github.com/Agoric/agoric-sdk/golang/cosmos/x/swingset/types"
-)
-
-// UpdateParams performs the parameter updates to migrate to version 2,
-// returning the updated params or an error.
-func UpdateParams(params types.Params) (types.Params, error) {
-	newBpu, err := addStorageBeanCost(params.BeansPerUnit)
-	if err != nil {
-		return params, err
-	}
-	params.BeansPerUnit = newBpu
-	return params, nil
-}
-
-// addStorageBeanCost adds the default beans per storage byte cost,
-// if it's not in the list of bean costs already, returning the possibly-updated list.
-// or an error if there's no default storage cost.
-func addStorageBeanCost(bpu []types.StringBeans) ([]types.StringBeans, error) {
-	for _, ob := range bpu {
-		if ob.Key == types.BeansPerStorageByte {
-			// success if there's already an entry
-			return bpu, nil
-		}
-	}
-	defaultParams := types.DefaultParams()
-	for _, b := range defaultParams.BeansPerUnit {
-		if b.Key == types.BeansPerStorageByte {
-			return append(bpu, b), nil
-		}
-	}
-	return bpu, fmt.Errorf("no beans per storage byte in default params %v", defaultParams)
-}