feat: implement dispatch msg

docs/core/proto-docs.md

@@ -9183,6 +9183,11 @@ Contains the values needed to calculate "all inputs hash".
 
 
 
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `results` | [bytes](#bytes) | repeated |  |
+
+
 
 
 

proto/finschia/zkauth/v1beta1/tx.proto

@@ -22,7 +22,9 @@ message MsgExecution {
     ZKAuthSignature zk_auth_signature = 2 [(gogoproto.nullable) = false];
 }
 
-message MsgExecutionResponse {}
+message MsgExecutionResponse {
+    repeated bytes results = 1;
+}
 
 message ZKAuthSignature {
     ZKAuthInputs zk_auth_inputs = 1;

x/zkauth/client/cli/tx.go

@@ -2,10 +2,14 @@ package cli
 
 import (
 	"fmt"
+	"os"
+	"strconv"
 
 	"github.com/spf13/cobra"
 
 	"github.com/Finschia/finschia-sdk/client"
+	"github.com/Finschia/finschia-sdk/client/tx"
+	authclient "github.com/Finschia/finschia-sdk/x/auth/client"
 	"github.com/Finschia/finschia-sdk/x/zkauth/types"
 )
 
@@ -19,5 +23,50 @@ func GetTxCmd() *cobra.Command {
 		RunE:                       client.ValidateCmd,
 	}
 
+	cmd.AddCommand(
+		NewCmdExecution(),
+	)
+
+	return cmd
+}
+
+func NewCmdExecution() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "execuion [tx_json_file] [zk_proof_json_file] [max_block_height]",
+		Short: "execute zkauth tx",
+		Long:  "execute zkauth tx",
+		Args:  cobra.ExactArgs(3),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			clientCtx, err := client.GetClientTxContext(cmd)
+			if err != nil {
+				return err
+			}
+
+			theTx, err := authclient.ReadTxFromFile(clientCtx, args[0])
+			if err != nil {
+				return err
+			}
+
+			var zkAuthInputs types.ZKAuthInputs
+			bytes, err := os.ReadFile(args[1])
+			if err != nil {
+				return err
+			}
+			clientCtx.Codec.UnmarshalInterfaceJSON(bytes, &zkAuthInputs)
+			maxBlockHeight, err := strconv.ParseUint(args[2], 10, 64)
+			if err != nil {
+				return err
+			}
+
+			zkAuthSign := types.ZKAuthSignature{
+				ZkAuthInputs:   &zkAuthInputs,
+				MaxBlockHeight: maxBlockHeight,
+			}
+			msg := types.NewMsgExecution(theTx.GetMsgs(), zkAuthSign)
+
+			return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg)
+		},
+	}
+
 	return cmd
 }

x/zkauth/keeper/keeper.go

@@ -7,35 +7,81 @@ import (
 	"net/http"
 	"os"
 	"path/filepath"
+	"strconv"
 	"time"
 
+	"github.com/Finschia/finschia-sdk/baseapp"
 	"github.com/Finschia/finschia-sdk/codec"
 	storetypes "github.com/Finschia/finschia-sdk/store/types"
 	sdk "github.com/Finschia/finschia-sdk/types"
+	sdkerrors "github.com/Finschia/finschia-sdk/types/errors"
 	"github.com/Finschia/finschia-sdk/x/zkauth/types"
 	"github.com/Finschia/ostracon/libs/log"
+	abci "github.com/tendermint/tendermint/abci/types"
 )
 
 type Keeper struct {
 	cdc      codec.BinaryCodec
 	storeKey storetypes.StoreKey
+	router   *baseapp.MsgServiceRouter
 }
 
 func NewKeeper(
 	cdc codec.BinaryCodec,
 	storeKey storetypes.StoreKey,
+	router *baseapp.MsgServiceRouter,
 ) *Keeper {
 
 	return &Keeper{
 		cdc:      cdc,
 		storeKey: storeKey,
+		router:   router,
 	}
 }
 
 func (k Keeper) Logger(ctx sdk.Context) log.Logger {
 	return ctx.Logger().With("module", fmt.Sprintf("x/%s", types.ModuleName))
 }
 
+func (k Keeper) DispatchMsgs(ctx sdk.Context, msgs []sdk.Msg) ([][]byte, error) {
+	results := make([][]byte, len(msgs))
+
+	for i, msg := range msgs {
+		signers := msg.GetSigners()
+		if len(signers) != 1 {
+			return nil, sdkerrors.ErrInvalidRequest.Wrap("authorization can be given to msg with only one signer")
+		}
+		if err := msg.ValidateBasic(); err != nil {
+			return nil, err
+		}
+
+		handler := k.router.Handler(msg)
+		if handler == nil {
+			return nil, sdkerrors.ErrUnknownRequest.Wrapf("unrecognized message route: %s", sdk.MsgTypeURL(msg))
+		}
+
+		msgResp, err := handler(ctx, msg)
+		if err != nil {
+			return nil, sdkerrors.Wrapf(err, "failed to execute message; message %v", msg)
+		}
+
+		results[i] = msgResp.Data
+
+		events := msgResp.Events
+		sdkEvents := make([]sdk.Event, 0, len(events))
+		for _, event := range events {
+			e := event
+			e.Attributes = append(e.Attributes, abci.EventAttribute{Key: []byte("zkauth_msg_index"), Value: []byte(strconv.Itoa(i))})
+
+			sdkEvents = append(sdkEvents, sdk.Event(e))
+		}
+
+		ctx.EventManager().EmitEvents(sdkEvents)
+	}
+
+	return results, nil
+}
+
 func (k Keeper) FetchJWK(ctx sdk.Context, nodeHome string) {
 	logger := k.Logger(ctx)
 	var defaultZKAuthOAuthProviders = [1]types.OidcProvider{types.Google}

x/zkauth/keeper/keeper_test.go

@@ -11,6 +11,9 @@ import (
 	"testing"
 	"time"
 
+	"github.com/Finschia/finschia-sdk/simapp"
+	sdk "github.com/Finschia/finschia-sdk/types"
+	banktypes "github.com/Finschia/finschia-sdk/x/bank/types"
 	"github.com/Finschia/finschia-sdk/x/zkauth/testutil"
 	"github.com/Finschia/finschia-sdk/x/zkauth/types"
 	"github.com/stretchr/testify/require"
@@ -53,7 +56,8 @@ func mockHandler(w http.ResponseWriter, r *http.Request) {
 }
 
 func TestGetJWK(t *testing.T) {
-	k, _ := testutil.ZkAuthKeeper(t)
+	testApp := testutil.ZkAuthKeeper(t)
+	k := testApp.Keeper
 	server := httptest.NewServer(http.HandlerFunc(mockHandler))
 	defer server.Close()
 
@@ -68,7 +72,8 @@ func TestGetJWK(t *testing.T) {
 }
 
 func TestParseJWKs(t *testing.T) {
-	k, _ := testutil.ZkAuthKeeper(t)
+	testApp := testutil.ZkAuthKeeper(t)
+	k := testApp.Keeper
 	server := httptest.NewServer(http.HandlerFunc(mockHandler))
 	defer server.Close()
 
@@ -86,8 +91,9 @@ func TestParseJWKs(t *testing.T) {
 func TestFetchJwk(t *testing.T) {
 	server := httptest.NewServer(http.HandlerFunc(mockHandler))
 	defer server.Close()
-	k, ctx := testutil.ZkAuthKeeper(t)
-
+	testApp := testutil.ZkAuthKeeper(t)
+	k := testApp.Keeper
+	ctx := testApp.Ctx
 	timeoutCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 	defer cancel()
 
@@ -108,3 +114,36 @@ func TestFetchJwk(t *testing.T) {
 	json.Unmarshal(content, &actualObj)
 	require.Equal(t, expectedObj, actualObj)
 }
+
+func TestDispatchMsgs(t *testing.T) {
+	testApp := testutil.ZkAuthKeeper(t)
+	app, k, ctx := testApp.Simapp, testApp.Keeper, testApp.Ctx
+
+	addrs := simapp.AddTestAddrs(app, ctx, 2, sdk.NewInt(100))
+	fromAddr := addrs[0]
+	toAddr := addrs[1]
+
+	newCoins := sdk.NewCoins(sdk.NewInt64Coin("stake", 5))
+
+	bankMsg := banktypes.MsgSend{
+		Amount:      newCoins,
+		FromAddress: fromAddr.String(),
+		ToAddress:   toAddr.String(),
+	}
+
+	zkAuthSig := types.ZKAuthSignature{}
+
+	msgs := types.NewMsgExecution([]sdk.Msg{&bankMsg}, zkAuthSig)
+
+	execMsgs, err := msgs.GetMessages()
+	require.NoError(t, err)
+	result, err := k.DispatchMsgs(ctx, execMsgs)
+
+	require.NoError(t, err)
+	require.NotNil(t, result)
+
+	fromBalance := app.BankKeeper.GetBalance(ctx, fromAddr, "stake")
+	require.True(t, fromBalance.Equal(sdk.NewInt64Coin("stake", 95)))
+	toBalance := app.BankKeeper.GetBalance(ctx, toAddr, "stake")
+	require.True(t, toBalance.Equal(sdk.NewInt64Coin("stake", 105)))
+}

x/zkauth/keeper/msg_server.go

@@ -3,6 +3,7 @@ package keeper
 import (
 	"context"
 
+	sdk "github.com/Finschia/finschia-sdk/types"
 	"github.com/Finschia/finschia-sdk/x/zkauth/types"
 )
 
@@ -19,5 +20,17 @@ func NewMsgServerImpl(keeper Keeper) types.MsgServer {
 var _ types.MsgServer = msgServer{}
 
 func (k msgServer) Execution(goCtx context.Context, msg *types.MsgExecution) (*types.MsgExecutionResponse, error) {
-	return &types.MsgExecutionResponse{}, nil
+	ctx := sdk.UnwrapSDKContext(goCtx)
+
+	msgs, err := msg.GetMessages()
+	if err != nil {
+		return nil, err
+	}
+
+	results, err := k.DispatchMsgs(ctx, msgs)
+	if err != nil {
+		return nil, err
+	}
+
+	return &types.MsgExecutionResponse{Results: results}, nil
 }

x/zkauth/keeper/msg_server_test.go

@@ -1,16 +1,41 @@
 package keeper_test
 
 import (
-	"context"
 	"testing"
 
+	"github.com/Finschia/finschia-sdk/simapp"
 	sdk "github.com/Finschia/finschia-sdk/types"
+	banktypes "github.com/Finschia/finschia-sdk/x/bank/types"
 	"github.com/Finschia/finschia-sdk/x/zkauth/keeper"
 	datest "github.com/Finschia/finschia-sdk/x/zkauth/testutil"
 	"github.com/Finschia/finschia-sdk/x/zkauth/types"
+	"github.com/stretchr/testify/require"
 )
 
-func setupMsgServer(t testing.TB) (types.MsgServer, context.Context) {
-	k, ctx := datest.ZkAuthKeeper(t)
-	return keeper.NewMsgServerImpl(*k), sdk.WrapSDKContext(ctx)
+func setupMsgServer(t testing.TB) (types.MsgServer, *simapp.SimApp, sdk.Context) {
+	testApp := datest.ZkAuthKeeper(t)
+	k, ctx := testApp.Keeper, testApp.Ctx
+	return keeper.NewMsgServerImpl(*k), testApp.Simapp, ctx
+}
+
+func TestExecution(t *testing.T) {
+	msgServer, app, ctx := setupMsgServer(t)
+	newCoins := sdk.NewCoins(sdk.NewInt64Coin("stake", 5))
+	addrs := simapp.AddTestAddrs(app, ctx, 2, sdk.NewInt(100))
+	fromAddr := addrs[0]
+	toAddr := addrs[1]
+
+	bankMsg := banktypes.MsgSend{
+		Amount:      newCoins,
+		FromAddress: fromAddr.String(),
+		ToAddress:   toAddr.String(),
+	}
+
+	zkAuthSig := types.ZKAuthSignature{}
+
+	msgs := types.NewMsgExecution([]sdk.Msg{&bankMsg}, zkAuthSig)
+
+	resp, err := msgServer.Execution(sdk.WrapSDKContext(ctx), msgs)
+	require.NoError(t, err)
+	require.NotNil(t, resp)
 }

x/zkauth/testutil/keeper.go

@@ -3,10 +3,10 @@ package testutil
 import (
 	"testing"
 
+	"github.com/Finschia/finschia-sdk/simapp"
 	"github.com/Finschia/finschia-sdk/x/zkauth/keeper"
 	"github.com/Finschia/finschia-sdk/x/zkauth/types"
 
-	"github.com/Finschia/ostracon/libs/log"
 	"github.com/stretchr/testify/require"
 	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
 	tmdb "github.com/tendermint/tm-db"
@@ -18,7 +18,15 @@ import (
 	sdk "github.com/Finschia/finschia-sdk/types"
 )
 
-func ZkAuthKeeper(t testing.TB) (*keeper.Keeper, sdk.Context) {
+type TestApp struct {
+	Simapp *simapp.SimApp
+	Keeper *keeper.Keeper
+	Ctx    sdk.Context
+}
+
+func ZkAuthKeeper(t testing.TB) TestApp {
+	checkTx := false
+	app := simapp.Setup(checkTx)
 	storeKey := sdk.NewKVStoreKey(types.StoreKey)
 	memStoreKey := storetypes.NewMemoryStoreKey(types.MemStoreKey)
 
@@ -34,9 +42,16 @@ func ZkAuthKeeper(t testing.TB) (*keeper.Keeper, sdk.Context) {
 	k := keeper.NewKeeper(
 		cdc,
 		storeKey,
+		app.MsgServiceRouter(),
 	)
 
-	ctx := sdk.NewContext(stateStore, tmproto.Header{}, false, log.NewNopLogger())
+	ctx := app.BaseApp.NewContext(false, tmproto.Header{})
+
+	testApp := TestApp{
+		Simapp: app,
+		Keeper: k,
+		Ctx:    ctx,
+	}
 
-	return k, ctx
+	return testApp
 }

x/zkauth/testutil/keeper_test.go

@@ -5,5 +5,5 @@ import (
 )
 
 func TestKeeper(t *testing.T) {
-	_, _ = ZkAuthKeeper(t)
+	_ = ZkAuthKeeper(t)
 }