@agoric/cosmos 0.34.2-upgrade-16-dev-8879538.0 → 0.34.2-upgrade-16-dev-24665a9.0

package/x/vlocalchain/vlocalchain_test.go

@@ -5,6 +5,7 @@ import (
 	"encoding/json"
 	"strings"
 	"testing"
+	"time"
 
 	"github.com/Agoric/agoric-sdk/golang/cosmos/app/params"
 	"github.com/Agoric/agoric-sdk/golang/cosmos/vm"
@@ -16,6 +17,7 @@ import (
 	storetypes "github.com/cosmos/cosmos-sdk/store/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
+	stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
 	transfertypes "github.com/cosmos/ibc-go/v6/modules/apps/transfer/types"
 	"github.com/tendermint/tendermint/libs/log"
 
@@ -77,8 +79,36 @@ func (t *mockTransfer) Transfer(cctx context.Context, msg *transfertypes.MsgTran
 	return &transfertypes.MsgTransferResponse{Sequence: 1}, nil
 }
 
+type mockStaking struct {
+	stakingtypes.UnimplementedMsgServer
+	stakingtypes.UnimplementedQueryServer
+}
+
+var _ stakingtypes.MsgServer = (*mockStaking)(nil)
+var _ stakingtypes.QueryServer = (*mockStaking)(nil)
+
+func (s *mockStaking) Undelegate(cctx context.Context, msg *stakingtypes.MsgUndelegate) (*stakingtypes.MsgUndelegateResponse, error) {
+	return &stakingtypes.MsgUndelegateResponse{CompletionTime: time.Now().UTC()}, nil
+}
+
+func (s *mockStaking) UnbondingDelegation(cctx context.Context, req *stakingtypes.QueryUnbondingDelegationRequest) (*stakingtypes.QueryUnbondingDelegationResponse, error) {
+	unbondingDelegation := stakingtypes.UnbondingDelegation{
+		DelegatorAddress: req.DelegatorAddr,
+		ValidatorAddress: "cosmosvaloper1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj",
+		Entries: []stakingtypes.UnbondingDelegationEntry{
+			{
+				CreationHeight: 100,
+				CompletionTime: time.Now().UTC().Add(time.Hour * 24 * 7),
+				InitialBalance: sdk.NewInt(1000),
+				Balance:        sdk.NewInt(500),
+			},
+		},
+	}
+	return &stakingtypes.QueryUnbondingDelegationResponse{Unbond: unbondingDelegation}, nil
+}
+
 // makeTestKit creates a minimal Keeper and Context for use in testing.
-func makeTestKit(bank *mockBank, transfer *mockTransfer) (vm.PortHandler, context.Context) {
+func makeTestKit(bank *mockBank, transfer *mockTransfer, staking *mockStaking) (vm.PortHandler, context.Context) {
 	encodingConfig := params.MakeEncodingConfig()
 	cdc := encodingConfig.Marshaler
 
@@ -93,6 +123,10 @@ func makeTestKit(bank *mockBank, transfer *mockTransfer) (vm.PortHandler, contex
 	transfertypes.RegisterInterfaces(encodingConfig.InterfaceRegistry)
 	transfertypes.RegisterMsgServer(txRouter, transfer)
 	transfertypes.RegisterQueryServer(queryRouter, transfer)
+	stakingtypes.RegisterInterfaces(encodingConfig.InterfaceRegistry)
+	stakingtypes.RegisterMsgServer(txRouter, staking)
+	stakingtypes.RegisterQueryServer(queryRouter, staking)
+
 
 	// create a new Keeper
 	keeper := vlocalchain.NewKeeper(cdc, vlocalchainStoreKey, txRouter, queryRouter)
@@ -118,7 +152,8 @@ func makeTestKit(bank *mockBank, transfer *mockTransfer) (vm.PortHandler, contex
 func TestAllocateAddress(t *testing.T) {
 	bank := &mockBank{}
 	transfer := &mockTransfer{}
-	handler, cctx := makeTestKit(bank, transfer)
+	staking := &mockStaking{}
+	handler, cctx := makeTestKit(bank, transfer, staking)
 
 	addrs := map[string]bool{
 		firstAddr: false,
@@ -161,7 +196,8 @@ func TestQuery(t *testing.T) {
 		alreadyAddr: []sdk.Coin{sdk.NewCoin("stale", sdk.NewInt(321))},
 	}}
 	transfer := &mockTransfer{}
-	handler, cctx := makeTestKit(bank, transfer)
+	staking := &mockStaking{}
+	handler, cctx := makeTestKit(bank, transfer, staking)
 
 	// get balances
 	testCases := []struct {
@@ -230,6 +266,68 @@ func TestQuery(t *testing.T) {
 			}
 		})
 	}
+
+	t.Run("UnbondingDelegation", func(t *testing.T) {
+		// create a new message
+		msg := `{"type":"VLOCALCHAIN_QUERY_MANY","messages":[{"@type":"/cosmos.staking.v1beta1.QueryUnbondingDelegationRequest","delegator_addr":"` + firstAddr + `","validator_addr":"cosmosvaloper1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj"}]}`
+		t.Logf("query request: %v", msg)
+		ret, err := handler.Receive(cctx, msg)
+		t.Logf("query response: %v", ret)
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		if ret == "" {
+			t.Fatalf("expected non-empty json")
+		}
+
+		// Unmarshal the JSON response
+		var respJSON []map[string]interface{}
+		if err := json.Unmarshal([]byte(ret), &respJSON); err != nil {
+			t.Fatalf("unexpected error unmarshalling JSON response: %v", err)
+		}
+
+		// Check the response fields
+		if len(respJSON) != 1 {
+			t.Fatalf("expected 1 response, got %d", len(respJSON))
+		}
+		resp := respJSON[0]
+
+		replyAny, ok := resp["reply"].(map[string]interface{})
+		if !ok {
+			t.Fatalf("expected reply field to be a map, got %v", resp["reply"])
+		}
+
+		unbond, ok := replyAny["unbond"].(map[string]interface{})
+		if !ok {
+			t.Fatalf("expected unbond field to be a map, got %v", replyAny["unbond"])
+		}
+
+		// Check the field names and values
+		if unbond["delegatorAddress"] != firstAddr {
+			t.Errorf("expected delegatorAddress %s, got %v", firstAddr, unbond["delegator_address"])
+		}
+		if unbond["validatorAddress"] != "cosmosvaloper1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj" {
+			t.Errorf("expected validatorAddress cosmosvaloper1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj, got %v", unbond["validator_address"])
+		}
+
+		entries, ok := unbond["entries"].([]interface{})
+		if !ok || len(entries) != 1 {
+			t.Fatalf("expected 1 unbonding delegation entry, got %v", entries)
+		}
+		entry, ok := entries[0].(map[string]interface{})
+		if !ok {
+			t.Fatalf("expected unbonding delegation entry to be a map, got %v", entries[0])
+		}
+		if entry["creationHeight"] != "100" {
+			t.Errorf("expected creationHeight \"100\", got %v", entry["creation_height"])
+		}
+		if entry["balance"] != "500" {
+			t.Errorf("expected balance \"500\", got %v", entry["balance"])
+		}
+		if _, ok := entry["completionTime"]; !ok {
+			t.Error("expected completionTime field in the response")
+		}
+	})
 }
 
 func TestExecuteTx(t *testing.T) {
@@ -239,7 +337,8 @@ func TestExecuteTx(t *testing.T) {
 		alreadyAddr: []sdk.Coin{sdk.NewCoin("stale", sdk.NewInt(321))},
 	}}
 	transfer := &mockTransfer{}
-	handler, cctx := makeTestKit(bank, transfer)
+	staking := &mockStaking{}
+	handler, cctx := makeTestKit(bank, transfer, staking)
 
 	// create a new message
 	msg := `{"type":"VLOCALCHAIN_ALLOCATE_ADDRESS"}`
@@ -302,4 +401,34 @@ func TestExecuteTx(t *testing.T) {
 			}
 		})
 	}
+
+	t.Run("MsgUndelegate", func(t *testing.T) {
+		// create a new message
+		msg := `{"type":"VLOCALCHAIN_EXECUTE_TX","address":"` + addr +
+			`","messages":[{"@type":"/cosmos.staking.v1beta1.MsgUndelegate","delegatorAddress":"` +
+			addr + `","validatorAddress":"cosmosvaloper1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj","amount":{"denom":"stake","amount":"100"}}]}`
+
+		ret, err := handler.Receive(cctx, msg)
+		if err != nil {
+			t.Fatalf("unexpected error: %s", err)
+		}
+		if ret == "" {
+			t.Fatalf("expected non-empty json")
+		}
+
+		// Unmarshal the response
+		var resp []map[string]interface{}
+		if err := json.Unmarshal([]byte(ret), &resp); err != nil {
+			t.Fatalf("unexpected error unmarshalling response: %v", err)
+		}
+
+		// Check the response fields
+		if len(resp) != 1 {
+			t.Fatalf("expected 1 response, got %d", len(resp))
+		}
+		
+		if _, ok := resp[0]["completionTime"]; !ok {
+			t.Error("expected 'completionTime' field in response")
+		}
+	})
 }

package/x/vstorage/keeper/keeper.go

@@ -421,7 +421,7 @@ func (k Keeper) GetNoDataValue() []byte {
 	return types.EncodedNoDataValue
 }
 
-func (k Keeper) getIntValue(ctx sdk.Context, path string) (sdkmath.Int, error) {
+func (k Keeper) GetIntValue(ctx sdk.Context, path string) (sdkmath.Int, error) {
 	indexEntry := k.GetEntry(ctx, path)
 	if !indexEntry.HasValue() {
 		return sdk.NewInt(0), nil
@@ -435,11 +435,11 @@ func (k Keeper) getIntValue(ctx sdk.Context, path string) (sdkmath.Int, error) {
 }
 
 func (k Keeper) GetQueueLength(ctx sdk.Context, queuePath string) (sdkmath.Int, error) {
-	head, err := k.getIntValue(ctx, queuePath+".head")
+	head, err := k.GetIntValue(ctx, queuePath+".head")
 	if err != nil {
 		return sdkmath.NewInt(0), err
 	}
-	tail, err := k.getIntValue(ctx, queuePath+".tail")
+	tail, err := k.GetIntValue(ctx, queuePath+".tail")
 	if err != nil {
 		return sdkmath.NewInt(0), err
 	}
@@ -450,12 +450,12 @@ func (k Keeper) GetQueueLength(ctx sdk.Context, queuePath string) (sdkmath.Int,
 func (k Keeper) PushQueueItem(ctx sdk.Context, queuePath string, value string) error {
 	// Get the current queue tail, defaulting to zero if its vstorage doesn't exist.
 	// The `tail` is the value of the next index to be inserted
-	tail, err := k.getIntValue(ctx, queuePath+".tail")
+	tail, err := k.GetIntValue(ctx, queuePath+".tail")
 	if err != nil {
 		return err
 	}
 
-	if tail.Equal(MaxSDKInt) {
+	if tail.GTE(MaxSDKInt) {
 		return errors.New(queuePath + " overflow")
 	}
 	nextTail := tail.Add(sdk.NewInt(1))

package/x/vstorage/testing/queue.go

@@ -0,0 +1,27 @@
+package testing
+
+import (
+	"fmt"
+
+	keeper "github.com/Agoric/agoric-sdk/golang/cosmos/x/vstorage/keeper"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+func GetQueueItems(ctx sdk.Context, vstorageKeeper keeper.Keeper, queuePath string) ([]string, error) {
+	head, err := vstorageKeeper.GetIntValue(ctx, queuePath+".head")
+	if err != nil {
+		return nil, err
+	}
+	tail, err := vstorageKeeper.GetIntValue(ctx, queuePath+".tail")
+	if err != nil {
+		return nil, err
+	}
+	length := tail.Sub(head).Int64()
+	values := make([]string, length)
+	var i int64
+	for i = 0; i < length; i++ {
+		path := fmt.Sprintf("%s.%s", queuePath, head.Add(sdk.NewInt(i)).String())
+		values[i] = vstorageKeeper.GetEntry(ctx, path).StringValue()
+	}
+	return values, nil
+}

package/x/vtransfer/alias.go

@@ -0,0 +1,13 @@
+package vtransfer
+
+import (
+	"github.com/Agoric/agoric-sdk/golang/cosmos/x/vtransfer/keeper"
+	"github.com/Agoric/agoric-sdk/golang/cosmos/x/vtransfer/types"
+)
+
+const (
+	ModuleName = types.ModuleName
+	StoreKey   = types.StoreKey
+)
+
+type Keeper = keeper.Keeper

package/x/vtransfer/genesis.go

@@ -0,0 +1,39 @@
+package vtransfer
+
+import (
+	"fmt"
+
+	"github.com/Agoric/agoric-sdk/golang/cosmos/x/vtransfer/types"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	abci "github.com/tendermint/tendermint/abci/types"
+)
+
+func NewGenesisState() *types.GenesisState {
+	return &types.GenesisState{}
+}
+
+func ValidateGenesis(data *types.GenesisState) error {
+	if data == nil {
+		return fmt.Errorf("vtransfer genesis data cannot be nil")
+	}
+	return nil
+}
+
+func DefaultGenesisState() *types.GenesisState {
+	return &types.GenesisState{}
+}
+
+func InitGenesis(ctx sdk.Context, keeper Keeper, data *types.GenesisState) []abci.ValidatorUpdate {
+	keeper.SetWatchedAddresses(ctx, data.GetWatchedAddresses())
+	return []abci.ValidatorUpdate{}
+}
+
+func ExportGenesis(ctx sdk.Context, k Keeper) *types.GenesisState {
+	var gs types.GenesisState
+	addresses, err := k.GetWatchedAddresses(ctx)
+	if err != nil {
+		panic(err)
+	}
+	gs.WatchedAddresses = addresses
+	return &gs
+}

package/x/vtransfer/genesis_test.go

@@ -0,0 +1,12 @@
+package vtransfer
+
+import (
+	"testing"
+)
+
+func TestDefaultGenesis(t *testing.T) {
+	defaultGenesisState := DefaultGenesisState()
+	if err := ValidateGenesis(defaultGenesisState); err != nil {
+		t.Errorf("DefaultGenesisState did not validate %v: %e", defaultGenesisState, err)
+	}
+}

package/x/vtransfer/handler.go

@@ -0,0 +1,20 @@
+package vtransfer
+
+import (
+	"fmt"
+
+	"github.com/Agoric/agoric-sdk/golang/cosmos/x/vtransfer/keeper"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+)
+
+// NewHandler returns a handler for "vtransfer" type messages.
+func NewHandler(keeper keeper.Keeper) sdk.Handler {
+	return func(ctx sdk.Context, msg sdk.Msg) (*sdk.Result, error) {
+		switch msg := msg.(type) {
+		default:
+			errMsg := fmt.Sprintf("Unrecognized vtransfer Msg type: %T", msg)
+			return nil, sdkerrors.Wrap(sdkerrors.ErrUnknownRequest, errMsg)
+		}
+	}
+}

package/x/vtransfer/ibc_middleware.go

@@ -0,0 +1,186 @@
+package vtransfer
+
+import (
+	"github.com/Agoric/agoric-sdk/golang/cosmos/x/vtransfer/keeper"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	capabilitytypes "github.com/cosmos/cosmos-sdk/x/capability/types"
+	clienttypes "github.com/cosmos/ibc-go/v6/modules/core/02-client/types"
+	channeltypes "github.com/cosmos/ibc-go/v6/modules/core/04-channel/types"
+	porttypes "github.com/cosmos/ibc-go/v6/modules/core/05-port/types"
+	"github.com/cosmos/ibc-go/v6/modules/core/exported"
+)
+
+// IBCMiddleware (https://ibc.cosmos.network/main/ibc/apps/ibcmodule) forwards
+// most of its methods to the next layer in the stack (which may be the ibc-go
+// transfer application or another middleware), but hooks the packet-related
+// methods and sends them to vtransferKeeper for async interception by the
+// associated VM:
+//
+// 1. IBCModule channel handshake callbacks (OnChanOpenInit, OnChanOpenTry,
+// OnChanOpenAck, and OnChanOpenConfirm)—handled by the wrapped IBCModule.
+//
+// 2. IBCModule channel closing callbacks (OnChanCloseInit and
+// OnChanCloseConfirm)—handled by the wrapped IBCModule.
+//
+// 3. IBCModule packet callbacks (OnRecvPacket, OnAcknowledgementPacket, and
+// OnTimeoutPacket)—intercepted by vtransfer.
+//
+// 4. ICS4Wrapper packet initiation methods (SendPacket, WriteAcknowledgement
+// and GetAppVersion)—delegated by vtransfer to vibc.
+
+var _ porttypes.Middleware = (*IBCMiddleware)(nil)
+
+// IBCMiddleware implements the ICS26 callbacks for the middleware given the
+// underlying IBCModule and the keeper.
+type IBCMiddleware struct {
+	ibcModule       porttypes.IBCModule
+	vtransferKeeper keeper.Keeper
+}
+
+// NewIBCMiddleware creates a new IBCMiddleware given the underlying IBCModule and keeper.
+func NewIBCMiddleware(ibcModule porttypes.IBCModule, vtransferKeeper keeper.Keeper) IBCMiddleware {
+	return IBCMiddleware{
+		ibcModule:       ibcModule,
+		vtransferKeeper: vtransferKeeper,
+	}
+}
+
+///////////////////////////////////
+// The following channel handshake events are all directly forwarded to the
+// wrapped IBCModule.  They are not performed in the context of a packet, and so
+// do not need to be intercepted.
+
+// OnChanCloseInit implements the IBCModule interface.
+func (im IBCMiddleware) OnChanOpenInit(
+	ctx sdk.Context,
+	order channeltypes.Order,
+	connectionHops []string,
+	portID string,
+	channelID string,
+	chanCap *capabilitytypes.Capability,
+	counterparty channeltypes.Counterparty,
+	version string,
+) (string, error) {
+	return im.ibcModule.OnChanOpenInit(ctx, order, connectionHops, portID, channelID, chanCap, counterparty, version)
+}
+
+// OnChanOpenTry implements the IBCModule interface.
+func (im IBCMiddleware) OnChanOpenTry(
+	ctx sdk.Context,
+	order channeltypes.Order,
+	connectionHops []string,
+	portID,
+	channelID string,
+	chanCap *capabilitytypes.Capability,
+	counterparty channeltypes.Counterparty,
+	counterpartyVersion string,
+) (string, error) {
+	return im.ibcModule.OnChanOpenTry(ctx, order, connectionHops, portID, channelID, chanCap, counterparty, counterpartyVersion)
+}
+
+// OnChanOpenAck implements the IBCModule interface.
+func (im IBCMiddleware) OnChanOpenAck(
+	ctx sdk.Context,
+	portID,
+	channelID string,
+	counterpartyChannelID string,
+	counterpartyVersion string,
+) error {
+	return im.ibcModule.OnChanOpenAck(ctx, portID, channelID, counterpartyChannelID, counterpartyVersion)
+}
+
+// OnChanOpenConfirm implements the IBCModule interface.
+func (im IBCMiddleware) OnChanOpenConfirm(
+	ctx sdk.Context,
+	portID,
+	channelID string,
+) error {
+	return im.ibcModule.OnChanOpenConfirm(ctx, portID, channelID)
+}
+
+// OnChanCloseInit implements the IBCModule interface.
+func (im IBCMiddleware) OnChanCloseInit(
+	ctx sdk.Context,
+	portID,
+	channelID string,
+) error {
+	return im.ibcModule.OnChanCloseInit(ctx, portID, channelID)
+}
+
+// OnChanCloseConfirm implements the IBCModule interface.
+func (im IBCMiddleware) OnChanCloseConfirm(
+	ctx sdk.Context,
+	portID,
+	channelID string,
+) error {
+	return im.ibcModule.OnChanCloseConfirm(ctx, portID, channelID)
+}
+
+///////////////////////////////////
+// The following packet methods are all implemented by
+// im.vtransferKeeper.Intercept*, so named because those methods are "tee"s
+// combining the middleware stack with an interception of the packet event
+// (On*Packet) or packet method (WriteAcknowledgment) by the async VM.
+
+// OnRecvPacket implements the IBCModule interface.
+func (im IBCMiddleware) OnRecvPacket(
+	ctx sdk.Context,
+	packet channeltypes.Packet,
+	relayer sdk.AccAddress,
+) exported.Acknowledgement {
+	return im.vtransferKeeper.InterceptOnRecvPacket(ctx, im.ibcModule, packet, relayer)
+}
+
+// OnAcknowledgementPacket implements the IBCModule interface.
+func (im IBCMiddleware) OnAcknowledgementPacket(
+	ctx sdk.Context,
+	packet channeltypes.Packet,
+	acknowledgement []byte,
+	relayer sdk.AccAddress,
+) error {
+	return im.vtransferKeeper.InterceptOnAcknowledgementPacket(ctx, im.ibcModule, packet, acknowledgement, relayer)
+}
+
+// OnTimeoutPacket implements the IBCModule interface.
+func (im IBCMiddleware) OnTimeoutPacket(
+	ctx sdk.Context,
+	packet channeltypes.Packet,
+	relayer sdk.AccAddress,
+) error {
+	return im.vtransferKeeper.InterceptOnTimeoutPacket(ctx, im.ibcModule, packet, relayer)
+}
+
+// WriteAcknowledgement implements the ICS4 Wrapper interface.
+// Unlike implementations of IBCModule interface methods, implementations of
+// ICS4 Wrapper interface methods do not pass along the wrapped IBC module
+// because they support packet initiation.
+func (im IBCMiddleware) WriteAcknowledgement(
+	ctx sdk.Context,
+	chanCap *capabilitytypes.Capability,
+	packet exported.PacketI,
+	ack exported.Acknowledgement,
+) error {
+	return im.vtransferKeeper.InterceptWriteAcknowledgement(ctx, chanCap, packet, ack)
+}
+
+///////////////////////////////////
+// The following methods are directly implemented by the ICS4Wrapper outside of
+// us, whether the ibc-go stack or another middleware.
+
+// SendPacket implements the ICS4 Wrapper interface.
+func (im IBCMiddleware) SendPacket(
+	ctx sdk.Context,
+	chanCap *capabilitytypes.Capability,
+	sourcePort string,
+	sourceChannel string,
+	timeoutHeight clienttypes.Height,
+	timeoutTimestamp uint64,
+	data []byte,
+) (uint64, error) {
+	return im.vtransferKeeper.SendPacket(ctx, chanCap, sourcePort, sourceChannel, timeoutHeight, timeoutTimestamp, data)
+}
+
+// GetAppVersion implements the ICS4 Wrapper interface.
+func (im IBCMiddleware) GetAppVersion(ctx sdk.Context, portID, channelID string) (string, bool) {
+	return im.vtransferKeeper.GetAppVersion(ctx, portID, channelID)
+}