@agoric/cosmos 0.34.2-orchestration-dev-096c4e8.0 → 0.34.2-other-dev-3eb1a1d.0

package/vm/client_test.go

@@ -11,30 +11,28 @@ import (
 	"github.com/Agoric/agoric-sdk/golang/cosmos/vm"
 )
 
-type Sender func(ctx context.Context, needReply bool, str string) (string, error)
-
 type errorWrapper struct {
 	Error string `json:"error"`
 }
 
 // ConnectVMClientCodec creates an RPC client codec and a sender to the
 // in-process implementation of the VM.
-func ConnectVMClientCodec(ctx context.Context, nodePort int, sendFunc func(int, int, string)) (*vm.ClientCodec, Sender) {
-	vmClientCodec := vm.NewClientCodec(context.Background(), sendFunc)
+func ConnectVMClientCodec(ctx context.Context, nodePort int, sendFunc func(int, int, string)) (*vm.ClientCodec, vm.Sender) {
+	vmClientCodec := vm.NewClientCodec(ctx, sendFunc)
 	vmClient := rpc.NewClientWithCodec(vmClientCodec)
 
-	sendToNode := func(ctx context.Context, needReply bool, str string) (string, error) {
-		if str == "shutdown" {
+	sendToNode := func(ctx context.Context, needReply bool, jsonRequest string) (jsonReply string, err error) {
+		if jsonRequest == "shutdown" {
 			return "", vmClientCodec.Close()
 		}
 
 		msg := vm.Message{
-			Port: nodePort,
+			Port:       nodePort,
 			NeedsReply: needReply,
-			Data: str,
+			Data:       jsonRequest,
 		}
 		var reply string
-		err := vmClient.Call(vm.ReceiveMessageMethod, msg, &reply)
+		err = vmClient.Call(vm.ReceiveMessageMethod, msg, &reply)
 		return reply, err
 	}
 
@@ -42,34 +40,35 @@ func ConnectVMClientCodec(ctx context.Context, nodePort int, sendFunc func(int,
 }
 
 type Fixture struct {
-	SendToNode Sender
-	SendToGo func (port int, msgStr string) string
-	ReplyToGo func (replyPort int, isError bool, respStr string) int
+	SendToNode vm.Sender
+	SendToGo   func(port int, msgStr string) string
+	ReplyToGo  func(replyPort int, isError bool, respStr string) int
 }
 
-func NewFixture(t *testing.T) (*Fixture) {
+func NewFixture(t *testing.T) *Fixture {
 	nodePort := 42
 
 	f := &Fixture{}
+	agdServer := vm.NewAgdServer()
 
 	sendFunc := func(port int, reply int, str string) {
 		switch str {
-			case "ping":
-				time.AfterFunc(100*time.Millisecond, func() {
-					fmt.Printf("sendFunc: port=%d, reply=%d, str=%s\n", port, reply, str)
-					if reply != 0 {
-						f.ReplyToGo(reply, false, "pong")
-					}
-				})
-			case "wait":
-				time.AfterFunc(300*time.Millisecond, func() {
-					fmt.Printf("sendFunc: port=%d, reply=%d, str=%s\n", port, reply, str)
-					if reply != 0 {
-						f.ReplyToGo(reply, false, "done-waiting")
-					}
-				})
-			default:
-				t.Errorf("Unexpected message %s", str)
+		case "ping":
+			time.AfterFunc(100*time.Millisecond, func() {
+				fmt.Printf("sendFunc: port=%d, reply=%d, str=%s\n", port, reply, str)
+				if reply != 0 {
+					f.ReplyToGo(reply, false, "pong")
+				}
+			})
+		case "wait":
+			time.AfterFunc(300*time.Millisecond, func() {
+				fmt.Printf("sendFunc: port=%d, reply=%d, str=%s\n", port, reply, str)
+				if reply != 0 {
+					f.ReplyToGo(reply, false, "done-waiting")
+				}
+			})
+		default:
+			t.Errorf("Unexpected message %s", str)
 		}
 	}
 
@@ -78,23 +77,22 @@ func NewFixture(t *testing.T) (*Fixture) {
 		int(nodePort),
 		sendFunc,
 	)
-	agdServer := vm.NewAgdServer()
 
 	f.SendToNode = sendToNode
-	f.SendToGo = func (port int, msgStr string) string {
+	f.SendToGo = func(port int, msgStr string) string {
 		fmt.Println("Send to Go", msgStr)
 		var respStr string
 		message := &vm.Message{
-			Port: int(port),
+			Port:       int(port),
 			NeedsReply: true,
-			Data: msgStr,
+			Data:       msgStr,
 		}
-		
+
 		err := agdServer.ReceiveMessage(message, &respStr)
 		if err == nil {
 			return respStr
 		}
-	
+
 		// fmt.Fprintln(os.Stderr, "Cannot receive from controller", err)
 		errResp := errorWrapper{
 			Error: err.Error(),
@@ -106,7 +104,7 @@ func NewFixture(t *testing.T) (*Fixture) {
 		return string(respBytes)
 	}
 
-	f.ReplyToGo = func (replyPort int, isError bool, respStr string) int {
+	f.ReplyToGo = func(replyPort int, isError bool, respStr string) int {
 		if err := vmClientCodec.Receive(replyPort, isError, respStr); err != nil {
 			return 1
 		}

package/vm/controller.go

@@ -7,6 +7,9 @@ import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 )
 
+// Sender makes a request of our associated VM.
+type Sender func(ctx context.Context, needReply bool, jsonRequest string) (jsonReply string, err error)
+
 type ControllerAdmissionMsg interface {
 	sdk.Msg
 	CheckAdmissibility(sdk.Context, interface{}) error
@@ -21,20 +24,10 @@ type ControllerAdmissionMsg interface {
 	IsHighPriority(sdk.Context, interface{}) (bool, error)
 }
 
-var wrappedEmptySDKContext = sdk.WrapSDKContext(
-	sdk.Context{}.WithContext(context.Background()),
-)
-var controllerContext context.Context = wrappedEmptySDKContext
-
 type PortHandler interface {
 	Receive(context.Context, string) (string, error)
 }
 
-var portToHandler = make(map[int]PortHandler)
-var portToName = make(map[int]string)
-var nameToPort = make(map[string]int)
-var lastPort = 0
-
 type protectedPortHandler struct {
 	inner PortHandler
 }
@@ -54,31 +47,3 @@ func (h protectedPortHandler) Receive(ctx context.Context, str string) (ret stri
 func NewProtectedPortHandler(inner PortHandler) PortHandler {
 	return protectedPortHandler{inner}
 }
-
-func SetControllerContext(ctx sdk.Context) func() {
-	// We are only called by the controller, so we assume that it is billing its
-	// own meter usage.
-	controllerContext = sdk.WrapSDKContext(ctx.WithGasMeter(sdk.NewInfiniteGasMeter()))
-	return func() {
-		controllerContext = wrappedEmptySDKContext
-	}
-}
-
-func GetPort(name string) int {
-	return nameToPort[name]
-}
-
-func RegisterPortHandler(name string, portHandler PortHandler) int {
-	lastPort++
-	portToHandler[lastPort] = NewProtectedPortHandler(portHandler)
-	portToName[lastPort] = name
-	nameToPort[name] = lastPort
-	return lastPort
-}
-func UnregisterPortHandler(portNum int) error {
-	delete(portToHandler, portNum)
-	name := portToName[portNum]
-	delete(portToName, portNum)
-	delete(nameToPort, name)
-	return nil
-}

package/vm/core_proposals.go

@@ -1,5 +1,10 @@
 package vm
 
+import (
+	"encoding/json"
+	"fmt"
+)
+
 // CoreProposalStep is a set of core proposal configs which are executed
 // concurrently
 type CoreProposalStep []Jsonable
@@ -11,12 +16,27 @@ type CoreProposals struct {
 	Steps []CoreProposalStep `json:"steps"`
 }
 
+type ArbitraryCoreProposal struct {
+	Json json.RawMessage
+}
+
+func NewArbitraryCoreProposal(jsonStr string) *ArbitraryCoreProposal {
+	return &ArbitraryCoreProposal{Json: []byte(jsonStr)}
+}
+
 // CoreProposalStepForModules generates a single core proposal step from
 // the given modules, which will be executed concurrently during that step
-func CoreProposalStepForModules(modules ...string) CoreProposalStep {
+func CoreProposalStepForModules(modules ...Jsonable) CoreProposalStep {
 	step := make([]Jsonable, len(modules))
 	for i := range modules {
-		step[i] = modules[i]
+		switch m := modules[i].(type) {
+		case ArbitraryCoreProposal:
+			step[i] = m.Json
+		case string:
+			step[i] = m
+		default:
+			panic(fmt.Errorf("unexpected step type %T", m))
+		}
 	}
 	return step
 }

package/vm/proto_json.go

@@ -0,0 +1,38 @@
+package vm
+
+import (
+	"encoding/json"
+
+	"github.com/gogo/protobuf/jsonpb"
+	"github.com/gogo/protobuf/proto"
+)
+
+// We need jsonpb for its access to the global registry.
+var marshaller = jsonpb.Marshaler{EmitDefaults: true}
+
+func ProtoJSONMarshal(val interface{}) ([]byte, error) {
+	if pm, ok := val.(proto.Message); ok {
+		var s string
+		s, err := marshaller.MarshalToString(pm)
+		return []byte(s), err
+	}
+
+	// Marshal a non-proto value to JSON.
+	return json.Marshal(val)
+}
+
+// ProtoJSONMarshalSlice marshals a slice of proto messages and non-proto values to
+// a single JSON byte slice.
+func ProtoJSONMarshalSlice(vals []interface{}) ([]byte, error) {
+	var err error
+	jsonSlice := make([]json.RawMessage, len(vals))
+	for i, val := range vals {
+		jsonSlice[i], err = ProtoJSONMarshal(val)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	// Marshal the JSON array to a single JSON byte slice.
+	return json.Marshal(jsonSlice)
+}

package/vm/proto_json_test.go

@@ -0,0 +1,103 @@
+package vm_test
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+
+	"github.com/Agoric/agoric-sdk/golang/cosmos/vm"
+
+	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"
+)
+
+func TestProtoJSONMarshal(t *testing.T) {
+	accAddr, err := sdk.AccAddressFromHexUnsafe("0123456789")
+	if err != nil {
+		panic(err)
+	}
+	valAddr, err := sdk.ValAddressFromHex("9876543210")
+	if err != nil {
+		panic(err)
+	}
+	coin := sdk.NewInt64Coin("uatom", 1234567)
+
+	testCases := []struct {
+		name     string
+		create   func() interface{}
+		expected string
+	}{
+		{
+			"nil",
+			func() interface{} {
+				return nil
+			},
+			`null`,
+		},
+		{
+			"primitive number",
+			func() interface{} {
+				return 12345
+			},
+			`12345`,
+		},
+		{
+			"MsgDelegate",
+			func() interface{} {
+				return stakingtypes.NewMsgDelegate(accAddr, valAddr, coin)
+			},
+			`{"delegatorAddress":"cosmos1qy352eufjjmc9c","validatorAddress":"cosmosvaloper1npm9gvss52mlmk","amount":{"denom":"uatom","amount":"1234567"}}`,
+		},
+		{
+			"QueryDenomOwnersResponse",
+			func() interface{} {
+				return &banktypes.QueryDenomOwnersResponse{
+					DenomOwners: []*banktypes.DenomOwner{
+						{
+							Address: accAddr.String(),
+							Balance: coin,
+						},
+						{
+							Address: valAddr.String(),
+							Balance: coin.Add(coin),
+						},
+					},
+				}
+			},
+			`{"denomOwners":[{"address":"cosmos1qy352eufjjmc9c","balance":{"denom":"uatom","amount":"1234567"}},{"address":"cosmosvaloper1npm9gvss52mlmk","balance":{"denom":"uatom","amount":"2469134"}}],"pagination":null}`,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			val := tc.create()
+			bz, err := vm.ProtoJSONMarshal(val)
+			if err != nil {
+				t.Errorf("ProtoJSONMarshal of %q failed %v", val, err)
+			}
+			if !bytes.Equal(bz, []byte(tc.expected)) {
+				t.Errorf("ProtoJSONMarshal of %q returned %q, expected %q", val, string(bz), tc.expected)
+			}
+		})
+	}
+
+	t.Run("all in a slice", func(t *testing.T) {
+		vals := make([]interface{}, len(testCases))
+		expectedJson := make([]string, len(testCases))
+		for i, tc := range testCases {
+			vals[i] = tc.create()
+			expectedJson[i] = tc.expected
+		}
+		bz, err := vm.ProtoJSONMarshalSlice(vals)
+		if err != nil {
+			t.Errorf("ProtoJSONMarshalSlice of %q failed %v", vals, err)
+		}
+
+		expected := "[" + strings.Join(expectedJson, ",") + "]"
+		if !bytes.Equal(bz, []byte(expected)) {
+			t.Errorf("ProtoJSONMarshalSlice of %q returned %q, expected %q", vals, string(bz), expected)
+		}
+	})
+}

package/vm/server.go

@@ -1,23 +1,124 @@
 package vm
 
 import (
+	"context"
 	"fmt"
+	"sync"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
 )
 
-type AgdServer struct{}
+// AgdServer manages communication from the VM to the ABCI app.  The structure
+// is mutable and the mutex must be held to read or write any field.
+type AgdServer struct {
+	currentCtx context.Context
+	mtx        sync.Mutex
+	// zero is an out-of-bounds port number
+	lastPort int
+	// portToHandler[i] is nonzero iff portToName[i] is nonempty
+	portToHandler map[int]PortHandler
+	// portToName[nameToPort[s]] == s && nameToPort[portToName[i]] == i for all i, s
+	portToName map[int]string
+	nameToPort map[string]int
+}
+
+var wrappedEmptySDKContext = sdk.WrapSDKContext(
+	sdk.Context{}.WithContext(context.Background()),
+)
 
+// NewAgdServer returns a pointer to a new AgdServer with empty context and port
+// mappings.
 func NewAgdServer() *AgdServer {
-	return &AgdServer{}
+	return &AgdServer{
+		currentCtx:    wrappedEmptySDKContext,
+		mtx:           sync.Mutex{},
+		portToHandler: make(map[int]PortHandler),
+		portToName:    make(map[int]string),
+		nameToPort:    make(map[string]int),
+	}
+}
+
+// SetControllerContext sets the context to the given argument and returns a function
+// which will reset the context to an empty context (not the old context).
+func (s *AgdServer) SetControllerContext(ctx sdk.Context) func() {
+	// We are only called by the controller, so we assume that it is billing its
+	// own meter usage.
+	s.mtx.Lock()
+	defer s.mtx.Unlock()
+	s.currentCtx = sdk.WrapSDKContext(ctx.WithGasMeter(sdk.NewInfiniteGasMeter()))
+	return func() {
+		s.mtx.Lock()
+		defer s.mtx.Unlock()
+		s.currentCtx = wrappedEmptySDKContext
+	}
+}
+
+// getContextAndHandler returns the current context and the handler for the
+// given port number.
+func (s *AgdServer) getContextAndHandler(port int) (context.Context, PortHandler) {
+	s.mtx.Lock()
+	defer s.mtx.Unlock()
+	ctx := s.currentCtx
+	handler := s.portToHandler[port]
+	return ctx, handler
 }
 
 // ReceiveMessage is the method the VM calls in order to have agd receive a
 // Message.
-func (s AgdServer) ReceiveMessage(msg *Message, reply *string) error {
-	handler := portToHandler[msg.Port]
+func (s *AgdServer) ReceiveMessage(msg *Message, reply *string) error {
+	ctx, handler := s.getContextAndHandler(msg.Port)
 	if handler == nil {
 		return fmt.Errorf("unregistered port %d", msg.Port)
 	}
-	resp, err := handler.Receive(controllerContext, msg.Data)
+	resp, err := handler.Receive(ctx, msg.Data)
 	*reply = resp
 	return err
 }
+
+// GetPort returns the port number for the given port name, or 0 if the name is
+// not registered.
+func (s *AgdServer) GetPort(name string) int {
+	s.mtx.Lock()
+	defer s.mtx.Unlock()
+	return s.nameToPort[name]
+}
+
+// MustRegisterPortHandler attempts to RegisterPortHandler, panicing on error.
+func (s *AgdServer) MustRegisterPortHandler(name string, portHandler PortHandler) int {
+	port, err := s.RegisterPortHandler(name, portHandler)
+	if err != nil {
+		panic(err)
+	}
+	return port
+}
+
+// RegisterPortHandler registers the handler to a new port number, then maps the name to it,
+// returning the port number. If the name was previously in use, an error is returned.
+func (s *AgdServer) RegisterPortHandler(name string, portHandler PortHandler) (int, error) {
+	s.mtx.Lock()
+	defer s.mtx.Unlock()
+	if _, ok := s.nameToPort[name]; ok {
+		return 0, fmt.Errorf("name %s already in use", name)
+	}
+	s.lastPort++
+	s.portToHandler[s.lastPort] = NewProtectedPortHandler(portHandler)
+	s.portToName[s.lastPort] = name
+	s.nameToPort[name] = s.lastPort
+	return s.lastPort, nil
+}
+
+// UnregisterPortHandler unregisters the handler and name mappings for this port
+// number, and the reverse mapping for its name, if any of these exist.  If
+// portNum is not registered, return an error.
+func (s *AgdServer) UnregisterPortHandler(portNum int) error {
+	s.mtx.Lock()
+	defer s.mtx.Unlock()
+	if s.portToHandler[portNum] == nil {
+		return fmt.Errorf("port %d not registered", portNum)
+	}
+	delete(s.portToHandler, portNum)
+	name := s.portToName[portNum]
+	delete(s.portToName, portNum)
+	delete(s.nameToPort, name)
+	return nil
+}

package/x/swingset/alias.go

@@ -24,6 +24,8 @@ type (
 	Keeper                   = keeper.Keeper
 	SwingStoreExportsHandler = keeper.SwingStoreExportsHandler
 	ExtensionSnapshotter     = keeper.ExtensionSnapshotter
+	ActionContext            = types.ActionContext
+	InboundQueueRecord       = types.InboundQueueRecord
 	Egress                   = types.Egress
 	MsgDeliverInbound        = types.MsgDeliverInbound
 	MsgProvision             = types.MsgProvision