vm

type Action ¶

type Action interface {
	GetActionHeader() *ActionHeader
}

func PopulateAction(ctx sdk.Context, action Action) Action

type ActionHeader ¶

type ActionHeader struct {
	// Type defaults to the `actionType:"..."` tag of the embedder's ActionHeader field.
	Type string `json:"type,omitempty"`
	// BlockHeight defaults to sdk.Context.BlockHeight().
	BlockHeight int64 `json:"blockHeight,omitempty"`
	// BlockTime defaults to sdk.Context.BlockTime().Unix().
	BlockTime int64 `json:"blockTime,omitempty"`
}

ActionHeader should be embedded in all actions. It is populated by PopulateAction.

func (ah *ActionHeader) GetActionHeader() *ActionHeader

type ActionPusher ¶

type ActionPusher func(ctx sdk.Context, action Action) error

ActionPusher enqueues data for later consumption by the controller.

type AgdServer ¶

type AgdServer struct {
	// contains filtered or unexported fields
}

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.

func NewAgdServer() *AgdServer

func (s *AgdServer) GetPort(name string) int

func (s *AgdServer) MustRegisterPortHandler(name string, portHandler PortHandler) int

func (s *AgdServer) ReceiveMessage(msg *Message, reply *string) error

func (s *AgdServer) RegisterPortHandler(name string, portHandler PortHandler) (int, error)

func (s *AgdServer) SetControllerContext(ctx sdk.Context) func()

func (s *AgdServer) UnregisterPortHandler(portNum int) error

type ClientCodec ¶

type ClientCodec struct {
	// contains filtered or unexported fields
}

ClientCodec implements a net/rpc ClientCodec for the "bridge" between the Go runtime and the VM in the single-process dual-runtime configuration.

We expect to call it via the legacy API with signature:

sendToController func(needsReply bool, msg string) (string, error)

where msg and the returned string are JSON-encoded values.

Note that the net/rpc framework cannot express a call that does not expect a response, so we'll note such calls by sending with a reply port of 0 and having the WriteRequest() method fabricate a Receive() call to clear the rpc state.

func NewClientCodec(ctx context.Context, send func(int, int, string)) *ClientCodec

func (cc *ClientCodec) Close() error

func (cc *ClientCodec) ReadResponseBody(body interface{}) error

func (cc *ClientCodec) ReadResponseHeader(r *rpc.Response) error

func (cc *ClientCodec) Receive(rPort int, isError bool, data string) error

func (cc *ClientCodec) WriteRequest(r *rpc.Request, body interface{}) error

type ControllerAdmissionMsg ¶

type ControllerAdmissionMsg interface {
	sdk.Msg
	CheckAdmissibility(sdk.Context, interface{}) error

	// GetInboundMsgCount returns the number of Swingset messages which will
	// be added to the inboundQueue.
	GetInboundMsgCount() int32

	// IsHighPriority returns whether the message should be considered for
	// high priority processing, including bypass of some inbound checks
	// and queueing on higher priority queues.
	IsHighPriority(sdk.Context, interface{}) (bool, error)
}

type CoreProposalStep ¶

type CoreProposalStep []Jsonable

CoreProposalStep is a set of core proposal configs which are executed concurrently

func CoreProposalStepForModules(modules ...string) CoreProposalStep

type CoreProposals ¶

type CoreProposals struct {
	Steps []CoreProposalStep `json:"steps"`
}

CoreProposals is one possible shape for core proposals expressed as a series of sequential steps see SequentialCoreProposals in packages/deploy-script-support/src/extract-proposal.js

func CoreProposalsFromSteps(steps ...CoreProposalStep) *CoreProposals

type Jsonable ¶

type Jsonable interface{}

Jsonable is a value, j, that can be passed through json.Marshal(j).

type Message ¶

type Message struct {
	Port       int
	Data       string
	NeedsReply bool
}

Message is what we send to the VM.

type PortHandler ¶

type PortHandler interface {
	Receive(context.Context, string) (string, error)
}

func NewProtectedPortHandler(inner PortHandler) PortHandler