@agoric/cosmos 0.35.0-u15.0 → 0.35.0-u16.0

package/vm/jsonrpcconn/jsonrpcconn_test.go

@@ -0,0 +1,126 @@
+package jsonrpcconn_test
+
+import (
+	"fmt"
+	"net"
+	"net/rpc"
+	"net/rpc/jsonrpc"
+	"testing"
+
+	"github.com/Agoric/agoric-sdk/golang/cosmos/vm/jsonrpcconn"
+)
+
+/*
+type testConn struct {
+	input  *bytes.Buffer
+	output *bytes.Buffer
+	done   chan struct{}
+}
+
+func newTestConn(input string) io.ReadWriteCloser {
+	return testConn{
+		input:  bytes.NewBufferString(input),
+		output: new(bytes.Buffer),
+		done:   make(chan struct{}),
+	}
+}
+
+func (tc testConn) Read(p []byte) (int, error) {
+	n, err := tc.input.Read(p)
+	if err == io.EOF {
+		<-tc.done
+	}
+	return n, err
+}
+
+func (tc testConn) Write(p []byte) (int, error) {
+	return tc.output.Write(p)
+}
+
+func (tc testConn) Close() error {
+	close(tc.done)
+	return nil
+}
+
+func TestMux(t *testing.T) {
+	input := `{"id": 1, "method": "foo", "params": [1, 2]}
+	{"id": "aaa", "result": true, "error": null}
+	{"id": null, "method": "bar", "params": ["string", 3, false]}`
+	tc := newTestConn(input)
+	client, server := jsonrpcconn.ClientServerConn(tc)
+	client.Read
+	var wg sync.WaitGroup
+	wg.Add(2)
+	go func() {
+
+	}()
+	wg.Wait()
+} */
+
+type Args struct {
+	A, B int
+}
+
+type Arith struct{}
+
+func (a *Arith) Add(args Args, reply *int) error {
+	*reply = args.A + args.B
+	return nil
+}
+
+func (a *Arith) Mul(args Args, reply *int) error {
+	*reply = args.A * args.B
+	return nil
+}
+
+func (a *Arith) Oops(args Args, reply *int) error {
+	return fmt.Errorf("oops")
+}
+
+func TestJsonRPC(t *testing.T) {
+	left, right := net.Pipe()
+	leftClientConn, leftServerConn := jsonrpcconn.ClientServerConn(left)
+	rightClientConn, rightServerConn := jsonrpcconn.ClientServerConn(right)
+
+	leftClient := jsonrpc.NewClient(leftClientConn)
+	leftServer := rpc.NewServer()
+	err := leftServer.RegisterName("foo", new(Arith))
+	if err != nil {
+		t.Fatal(err)
+	}
+	go leftServer.ServeCodec(jsonrpc.NewServerCodec(leftServerConn))
+
+	rightClient := jsonrpc.NewClient(rightClientConn)
+	rightServer := rpc.NewServer()
+	err = rightServer.RegisterName("bar", new(Arith))
+	if err != nil {
+		t.Fatal(err)
+	}
+	go rightServer.ServeCodec(jsonrpc.NewServerCodec(rightServerConn))
+
+	var reply int
+	err = leftClient.Call("bar.Add", Args{1, 2}, &reply)
+	if err != nil {
+		t.Error(err)
+	}
+	if reply != 3 {
+		t.Errorf("bar.Add want 3, got %d", reply)
+	}
+
+	err = rightClient.Call("foo.Mul", Args{2, 3}, &reply)
+	if err != nil {
+		t.Error(err)
+	}
+	if reply != 6 {
+		t.Errorf("foo.Mul want 6, got %d", reply)
+	}
+
+	err = leftClient.Call("bar.Oops", Args{7, 11}, &reply)
+	if err == nil {
+		t.Errorf("bar.Oops want error, got reply %d", reply)
+	} else if err.Error() != "oops" {
+		t.Errorf(`bar.Oops want error "oops", got "%s"`, err.Error())
+	}
+	leftClient.Close()
+	rightClient.Close()
+}

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

@@ -0,0 +1,124 @@
+package vm
+
+import (
+	"context"
+	"fmt"
+	"sync"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+// 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{
+		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 {
+	ctx, handler := s.getContextAndHandler(msg.Port)
+	if handler == nil {
+		return fmt.Errorf("unregistered port %d", msg.Port)
+	}
+	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/abci.go

@@ -15,27 +15,27 @@ import (
 )
 
 type beginBlockAction struct {
-	vm.ActionHeader `actionType:"BEGIN_BLOCK"`
-	ChainID         string       `json:"chainID"`
-	Params          types.Params `json:"params"`
+	*vm.ActionHeader `actionType:"BEGIN_BLOCK"`
+	ChainID          string       `json:"chainID"`
+	Params           types.Params `json:"params"`
 }
 
 type endBlockAction struct {
-	vm.ActionHeader `actionType:"END_BLOCK"`
+	*vm.ActionHeader `actionType:"END_BLOCK"`
 }
 
 type commitBlockAction struct {
-	vm.ActionHeader `actionType:"COMMIT_BLOCK"`
+	*vm.ActionHeader `actionType:"COMMIT_BLOCK"`
 }
 
 type afterCommitBlockAction struct {
-	vm.ActionHeader `actionType:"AFTER_COMMIT_BLOCK"`
+	*vm.ActionHeader `actionType:"AFTER_COMMIT_BLOCK"`
 }
 
 func BeginBlock(ctx sdk.Context, req abci.RequestBeginBlock, keeper Keeper) error {
 	defer telemetry.ModuleMeasureSince(types.ModuleName, time.Now(), telemetry.MetricKeyBeginBlocker)
 
-	action := &beginBlockAction{
+	action := beginBlockAction{
 		ChainID: ctx.ChainID(),
 		Params:  keeper.GetParams(ctx),
 	}
@@ -56,7 +56,7 @@ var endBlockTime int64
 func EndBlock(ctx sdk.Context, req abci.RequestEndBlock, keeper Keeper) ([]abci.ValidatorUpdate, error) {
 	defer telemetry.ModuleMeasureSince(types.ModuleName, time.Now(), telemetry.MetricKeyEndBlocker)
 
-	action := &endBlockAction{}
+	action := endBlockAction{}
 	_, err := keeper.BlockingSend(ctx, action)
 
 	// fmt.Fprintf(os.Stderr, "END_BLOCK Returned from SwingSet: %s, %v\n", out, err)
@@ -83,7 +83,7 @@ func getEndBlockContext() sdk.Context {
 func CommitBlock(keeper Keeper) error {
 	defer telemetry.ModuleMeasureSince(types.ModuleName, time.Now(), "commit_blocker")
 
-	action := &commitBlockAction{}
+	action := commitBlockAction{}
 	_, err := keeper.BlockingSend(getEndBlockContext(), action)
 
 	// fmt.Fprintf(os.Stderr, "COMMIT_BLOCK Returned from SwingSet: %s, %v\n", out, err)
@@ -98,7 +98,7 @@ func CommitBlock(keeper Keeper) error {
 func AfterCommitBlock(keeper Keeper) error {
 	// defer telemetry.ModuleMeasureSince(types.ModuleName, time.Now(), "commit_blocker")
 
-	action := &afterCommitBlockAction{}
+	action := afterCommitBlockAction{}
 	_, err := keeper.BlockingSend(getEndBlockContext(), action)
 
 	// fmt.Fprintf(os.Stderr, "AFTER_COMMIT_BLOCK Returned from SwingSet: %s, %v\n", out, err)

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

package/x/swingset/client/cli/tx.go

@@ -253,11 +253,13 @@ Specify at least one pair of permit.json and code.js files`,
 				return err
 			}
 
+			//nolint:staticcheck // Agoric is still using the legacy proposal shape
 			title, err := cmd.Flags().GetString(govcli.FlagTitle)
 			if err != nil {
 				return err
 			}
 
+			//nolint:staticcheck // Agoric is still using the legacy proposal shape
 			description, err := cmd.Flags().GetString(govcli.FlagDescription)
 			if err != nil {
 				return err
@@ -315,7 +317,9 @@ Specify at least one pair of permit.json and code.js files`,
 		},
 	}
 
+	//nolint:staticcheck // Agoric is still using the legacy proposal shape
 	cmd.Flags().String(govcli.FlagTitle, "", "title of proposal")
+	//nolint:staticcheck // Agoric is still using the legacy proposal shape
 	cmd.Flags().String(govcli.FlagDescription, "", "description of proposal")
 	cmd.Flags().String(govcli.FlagDeposit, "", "deposit for proposal")
 

package/x/swingset/genesis.go

@@ -2,7 +2,13 @@ package swingset
 
 import (
 	// "os"
+	"bytes"
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
 	"fmt"
+	"hash"
+	"strings"
 
 	agoric "github.com/Agoric/agoric-sdk/golang/cosmos/types"
 	"github.com/Agoric/agoric-sdk/golang/cosmos/x/swingset/keeper"
@@ -35,8 +41,10 @@ func InitGenesis(ctx sdk.Context, k Keeper, swingStoreExportsHandler *SwingStore
 	k.SetState(ctx, data.GetState())
 
 	swingStoreExportData := data.GetSwingStoreExportData()
-	if len(swingStoreExportData) == 0 {
+	if len(swingStoreExportData) == 0 && data.SwingStoreExportDataHash == "" {
 		return true
+	} else if data.SwingStoreExportDataHash != "" && len(swingStoreExportData) > 0 {
+		panic("Swingset genesis state cannot have both export data and hash of export data")
 	}
 
 	artifactProvider, err := keeper.OpenSwingStoreExportDirectory(swingStoreExportDir)
@@ -46,15 +54,62 @@ func InitGenesis(ctx sdk.Context, k Keeper, swingStoreExportsHandler *SwingStore
 
 	swingStore := k.GetSwingStore(ctx)
 
-	for _, entry := range swingStoreExportData {
-		swingStore.Set([]byte(entry.Key), []byte(entry.Value))
-	}
-
 	snapshotHeight := uint64(ctx.BlockHeight())
 
-	getExportDataReader := func() (agoric.KVEntryReader, error) {
-		exportDataIterator := swingStore.Iterator(nil, nil)
-		return agoric.NewKVIteratorReader(exportDataIterator), nil
+	var getExportDataReader func() (agoric.KVEntryReader, error)
+
+	if len(swingStoreExportData) > 0 {
+		for _, entry := range swingStoreExportData {
+			swingStore.Set([]byte(entry.Key), []byte(entry.Value))
+		}
+		getExportDataReader = func() (agoric.KVEntryReader, error) {
+			exportDataIterator := swingStore.Iterator(nil, nil)
+			return agoric.NewKVIteratorReader(exportDataIterator), nil
+		}
+	} else {
+		hashParts := strings.SplitN(data.SwingStoreExportDataHash, ":", 2)
+		if len(hashParts) != 2 {
+			panic(fmt.Errorf("invalid swing-store export data hash %s", data.SwingStoreExportDataHash))
+		}
+		if hashParts[0] != "sha256" {
+			panic(fmt.Errorf("invalid swing-store export data hash algorithm %s, expected sha256", hashParts[0]))
+		}
+		sha256Hash, err := hex.DecodeString(hashParts[1])
+		if err != nil {
+			panic(err)
+		}
+		getExportDataReader = func() (agoric.KVEntryReader, error) {
+			kvReader, err := artifactProvider.GetExportDataReader()
+			if err != nil {
+				return nil, err
+			}
+
+			if kvReader == nil {
+				return nil, fmt.Errorf("swing-store export has no export data")
+			}
+
+			hasher := sha256.New()
+			encoder := json.NewEncoder(hasher)
+			encoder.SetEscapeHTML(false)
+
+			return agoric.NewKVHookingReader(kvReader, func(entry agoric.KVEntry) error {
+				key := []byte(entry.Key())
+
+				if !entry.HasValue() {
+					swingStore.Delete(key)
+				} else {
+					swingStore.Set(key, []byte(entry.StringValue()))
+				}
+
+				return encoder.Encode(entry)
+			}, func() error {
+				sum := hasher.Sum(nil)
+				if !bytes.Equal(sum, sha256Hash) {
+					return fmt.Errorf("swing-store data sha256sum didn't match. expected %x, got %x", sha256Hash, sum)
+				}
+				return nil
+			}), nil
+		}
 	}
 
 	err = swingStoreExportsHandler.RestoreExport(
@@ -64,7 +119,7 @@ func InitGenesis(ctx sdk.Context, k Keeper, swingStoreExportsHandler *SwingStore
 			ReadNextArtifact:    artifactProvider.ReadNextArtifact,
 		},
 		keeper.SwingStoreRestoreOptions{
-			ArtifactMode:   keeper.SwingStoreArtifactModeReplay,
+			ArtifactMode:   keeper.SwingStoreArtifactModeOperational,
 			ExportDataMode: keeper.SwingStoreExportDataModeAll,
 		},
 	)
@@ -79,28 +134,19 @@ func ExportGenesis(ctx sdk.Context, k Keeper, swingStoreExportsHandler *SwingSto
 	gs := &types.GenesisState{
 		Params:               k.GetParams(ctx),
 		State:                k.GetState(ctx),
-		SwingStoreExportData: []*types.SwingStoreExportDataEntry{},
-	}
-
-	exportDataIterator := k.GetSwingStore(ctx).Iterator(nil, nil)
-	defer exportDataIterator.Close()
-	for ; exportDataIterator.Valid(); exportDataIterator.Next() {
-		entry := types.SwingStoreExportDataEntry{
-			Key:   string(exportDataIterator.Key()),
-			Value: string(exportDataIterator.Value()),
-		}
-		gs.SwingStoreExportData = append(gs.SwingStoreExportData, &entry)
+		SwingStoreExportData: nil,
 	}
 
 	snapshotHeight := uint64(ctx.BlockHeight())
 
+	eventHandler := swingStoreGenesisEventHandler{exportDir: swingStoreExportDir, snapshotHeight: snapshotHeight, swingStore: k.GetSwingStore(ctx), hasher: sha256.New()}
+
 	err := swingStoreExportsHandler.InitiateExport(
 		// The export will fail if the export of a historical height was requested
 		snapshotHeight,
-		swingStoreGenesisEventHandler{exportDir: swingStoreExportDir, snapshotHeight: snapshotHeight},
-		// The export will fail if the swing-store does not contain all replay artifacts
+		eventHandler,
 		keeper.SwingStoreExportOptions{
-			ArtifactMode:   keeper.SwingStoreArtifactModeReplay,
+			ArtifactMode:   keeper.SwingStoreArtifactModeOperational,
 			ExportDataMode: keeper.SwingStoreExportDataModeSkip,
 		},
 	)
@@ -113,12 +159,16 @@ func ExportGenesis(ctx sdk.Context, k Keeper, swingStoreExportsHandler *SwingSto
 		panic(err)
 	}
 
+	gs.SwingStoreExportDataHash = fmt.Sprintf("sha256:%x", eventHandler.hasher.Sum(nil))
+
 	return gs
 }
 
 type swingStoreGenesisEventHandler struct {
 	exportDir      string
 	snapshotHeight uint64
+	swingStore     sdk.KVStore
+	hasher         hash.Hash
 }
 
 func (eventHandler swingStoreGenesisEventHandler) OnExportStarted(height uint64, retrieveSwingStoreExport func() error) error {
@@ -132,7 +182,17 @@ func (eventHandler swingStoreGenesisEventHandler) OnExportRetrieved(provider kee
 
 	artifactsProvider := keeper.SwingStoreExportProvider{
 		GetExportDataReader: func() (agoric.KVEntryReader, error) {
-			return nil, nil
+			exportDataIterator := eventHandler.swingStore.Iterator(nil, nil)
+			kvReader := agoric.NewKVIteratorReader(exportDataIterator)
+			eventHandler.hasher.Reset()
+			encoder := json.NewEncoder(eventHandler.hasher)
+			encoder.SetEscapeHTML(false)
+
+			return agoric.NewKVHookingReader(kvReader, func(entry agoric.KVEntry) error {
+				return encoder.Encode(entry)
+			}, func() error {
+				return nil
+			}), nil
 		},
 		ReadNextArtifact: provider.ReadNextArtifact,
 	}

package/x/swingset/handler.go

@@ -5,6 +5,7 @@ import (
 
 	"github.com/Agoric/agoric-sdk/golang/cosmos/x/swingset/keeper"
 
+	sdkioerrors "cosmossdk.io/errors"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 )
@@ -29,7 +30,7 @@ func NewHandler(k Keeper) sdk.Handler {
 
 		default:
 			errMsg := fmt.Sprintf("Unrecognized swingset Msg type: %T", msg)
-			return nil, sdkerrors.Wrap(sdkerrors.ErrUnknownRequest, errMsg)
+			return nil, sdkioerrors.Wrap(sdkerrors.ErrUnknownRequest, errMsg)
 		}
 	}
 }

package/x/swingset/keeper/extension_snapshotter.go

@@ -125,7 +125,7 @@ func (snapshotter *ExtensionSnapshotter) InitiateSnapshot(height int64) error {
 	blockHeight := uint64(height)
 
 	return snapshotter.swingStoreExportsHandler.InitiateExport(blockHeight, snapshotter, SwingStoreExportOptions{
-		ArtifactMode:   SwingStoreArtifactModeReplay,
+		ArtifactMode:   SwingStoreArtifactModeOperational,
 		ExportDataMode: SwingStoreExportDataModeSkip,
 	})
 }
@@ -304,6 +304,6 @@ func (snapshotter *ExtensionSnapshotter) RestoreExtension(blockHeight uint64, fo
 
 	return snapshotter.swingStoreExportsHandler.RestoreExport(
 		SwingStoreExportProvider{BlockHeight: blockHeight, GetExportDataReader: getExportDataReader, ReadNextArtifact: readNextArtifact},
-		SwingStoreRestoreOptions{ArtifactMode: SwingStoreArtifactModeReplay, ExportDataMode: SwingStoreExportDataModeAll},
+		SwingStoreRestoreOptions{ArtifactMode: SwingStoreArtifactModeOperational, ExportDataMode: SwingStoreExportDataModeAll},
 	)
 }