Arweave message #6

app/app.go

@@ -106,6 +106,7 @@ import (
 	sequencermodule "github.com/warp-contracts/sequencer/x/sequencer"
 	sequencermodulekeeper "github.com/warp-contracts/sequencer/x/sequencer/keeper"
 	sequencermoduletypes "github.com/warp-contracts/sequencer/x/sequencer/types"
+	arweaveapi "github.com/warp-contracts/sequencer/x/sequencer/api"
 	// this line is used by starport scaffolding # stargate/app/moduleImport
 
 	appparams "github.com/warp-contracts/sequencer/app/params"
@@ -841,6 +842,9 @@ func (app *App) RegisterAPIRoutes(apiSvr *api.Server, apiConfig config.APIConfig
 
 	// register app's OpenAPI routes.
 	docs.RegisterOpenAPIService(Name, apiSvr.Router)
+
+	// Register the route for sending Arweave transactions as JSON
+	arweaveapi.RegisterArweaveAPIRoute(clientCtx, apiSvr.Router)
 }
 
 // RegisterTxService implements the Application.RegisterTxService method.

config.yml

@@ -18,3 +18,8 @@ faucet:
 validators:
 - name: alice
   bonded: 100000000warp
+genesis:
+  app_state:
+    staking:
+      params:
+        bond_denom: "warp"

docs/static/openapi.yml

@@ -71434,6 +71434,8 @@ definitions:
     description: |-
       Version defines the versioning scheme used to negotiate the IBC verison in
       the connection handshake.
+  warpcontracts.sequencer.sequencer.MsgArweaveResponse:
+    type: object
   warpcontracts.sequencer.sequencer.Params:
     type: object
     description: Params defines the parameters for the module.
@@ -71444,3 +71446,10 @@ definitions:
         description: params holds all the parameters of this module.
         type: object
     description: QueryParamsResponse is response type for the Query/Params RPC method.
+  warpcontracts.sequencer.sequencer.Tag:
+    type: object
+    properties:
+      name:
+        type: string
+      value:
+        type: string

proto/sequencer/sequencer/tx.proto

@@ -1,7 +1,33 @@
 syntax = "proto3";
+
 package warpcontracts.sequencer.sequencer;
 
 option go_package = "github.com/warp-contracts/sequencer/x/sequencer/types";
 
 // Msg defines the Msg service.
-service Msg {}
+service Msg {
+  rpc Arweave (MsgArweave) returns (MsgArweaveResponse);
+}
+message Tag {
+  string name = 1;
+  string value = 2;
+}
+
+message MsgArweave {
+  string creator   =  1;
+  int32 format    =  2;
+  string id        =  3;
+  string lastTx    =  4;
+  string owner     =  5;
+  repeated Tag tags =  6;
+  string target    =  7;
+  string quantity  =  8;
+  string dataRoot  =  9;
+  string dataSize  = 10;
+  string data      = 11;
+  string reward    = 12;
+  string signature = 13;
+}
+
+message MsgArweaveResponse {}
+

x/sequencer/api/arweave.go

@@ -0,0 +1,62 @@
+package api
+
+import (
+	"encoding/json"
+	"net/http"
+
+	"github.com/cosmos/cosmos-sdk/client"
+	"github.com/gorilla/mux"
+	"github.com/warp-contracts/sequencer/x/sequencer/types"
+)
+
+type arweaveHandler struct {
+	ctx client.Context
+}
+
+// The endpoint that accepts the Arweave transaction in the form of JSON, 
+// wraps it with a Cosmos transaction and broadcasts it to the network.
+func RegisterArweaveAPIRoute(clientCtx client.Context, router *mux.Router) {
+	router.Handle("/arweave", arweaveHandler{ctx: clientCtx}).Methods("POST")
+}
+
+func (h arweaveHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	// parse JSON
+	var msg types.MsgArweave
+	decoder := json.NewDecoder(r.Body)
+	decoder.DisallowUnknownFields()
+	err := decoder.Decode(&msg)
+	if err != nil {
+		badRequest(w, err.Error())
+		return
+	}
+
+	// wrap Arweave message with Cosmos transaction
+	txBytes, err := createTxWithArweaveMsg(h.ctx, msg)
+	if err != nil {
+		badRequest(w, err.Error())
+		return
+	}
+
+	// broadcast transaction
+	response, err := h.ctx.BroadcastTxSync(txBytes)
+	if err != nil {
+		badRequest(w, err.Error())
+		return
+	}
+	if response.Code != 0 {
+		badRequest(w, response.RawLog)
+		return
+	}
+
+	w.Write([]byte(response.TxHash))
+}
+
+func badRequest(w http.ResponseWriter, errorMessage string) {
+	http.Error(w, errorMessage, http.StatusBadRequest)
+}
+
+func createTxWithArweaveMsg(ctx client.Context, msg types.MsgArweave) ([]byte, error) {
+	txBuilder := ctx.TxConfig.NewTxBuilder()
+	txBuilder.SetMsgs(&msg)
+	return ctx.TxConfig.TxEncoder()(txBuilder.GetTx())
+}

x/sequencer/client/cli/tx.go

@@ -30,6 +30,7 @@ func GetTxCmd() *cobra.Command {
 		RunE:                       client.ValidateCmd,
 	}
 
+	cmd.AddCommand(CmdArweave())
 	// this line is used by starport scaffolding # 1
 
 	return cmd

x/sequencer/client/cli/tx_arweave.go

@@ -0,0 +1,67 @@
+package cli
+
+import (
+	"strconv"
+
+	"github.com/cosmos/cosmos-sdk/client"
+	"github.com/cosmos/cosmos-sdk/client/flags"
+	"github.com/cosmos/cosmos-sdk/client/tx"
+	"github.com/spf13/cobra"
+	"github.com/warp-contracts/sequencer/x/sequencer/types"
+)
+
+var _ = strconv.Itoa(0)
+
+func CmdArweave() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "arweave [format] [id] [last-tx] [owner] [tags] [target] [quantity] [data-root] [data-size] [data] [reward] [signature]",
+		Short: "Broadcast message arweave",
+		Args:  cobra.ExactArgs(12),
+		RunE: func(cmd *cobra.Command, args []string) (err error) {
+			argFormat := args[0]
+			argId := args[1]
+			argLastTx := args[2]
+			argOwner := args[3]
+			argTags := args[4]
+			argTarget := args[5]
+			argQuantity := args[6]
+			argDataRoot := args[7]
+			argDataSize := args[8]
+			argData := args[9]
+			argReward := args[10]
+			argSignature := args[11]
+
+			clientCtx, err := client.GetClientTxContext(cmd)
+			if err != nil {
+				return err
+			}
+
+			msg, err := types.NewMsgArweave(
+				clientCtx.GetFromAddress().String(),
+				argFormat,
+				argId,
+				argLastTx,
+				argOwner,
+				argTags,
+				argTarget,
+				argQuantity,
+				argDataRoot,
+				argDataSize,
+				argData,
+				argReward,
+				argSignature,
+			)
+			if err != nil {
+				return err
+			}
+			if err := msg.ValidateBasic(); err != nil {
+				return err
+			}
+			return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg)
+		},
+	}
+
+	flags.AddTxFlagsToCmd(cmd)
+
+	return cmd
+}

x/sequencer/keeper/msg_server_arweave.go

@@ -0,0 +1,17 @@
+package keeper
+
+import (
+	"context"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/warp-contracts/sequencer/x/sequencer/types"
+)
+
+func (k msgServer) Arweave(goCtx context.Context, msg *types.MsgArweave) (*types.MsgArweaveResponse, error) {
+	ctx := sdk.UnwrapSDKContext(goCtx)
+
+	// TODO: Handling the message
+	_ = ctx
+
+	return &types.MsgArweaveResponse{}, nil
+}

x/sequencer/module_simulation.go

@@ -24,7 +24,11 @@ var (
 )
 
 const (
-// this line is used by starport scaffolding # simapp/module/const
+	opWeightMsgArweave = "op_weight_msg_arweave"
+	// TODO: Determine the simulation weight value
+	defaultWeightMsgArweave int = 100
+
+	// this line is used by starport scaffolding # simapp/module/const
 )
 
 // GenerateGenesisState creates a randomized GenState of the module
@@ -58,6 +62,17 @@ func (am AppModule) RegisterStoreDecoder(_ sdk.StoreDecoderRegistry) {}
 func (am AppModule) WeightedOperations(simState module.SimulationState) []simtypes.WeightedOperation {
 	operations := make([]simtypes.WeightedOperation, 0)
 
+	var weightMsgArweave int
+	simState.AppParams.GetOrGenerate(simState.Cdc, opWeightMsgArweave, &weightMsgArweave, nil,
+		func(_ *rand.Rand) {
+			weightMsgArweave = defaultWeightMsgArweave
+		},
+	)
+	operations = append(operations, simulation.NewWeightedOperation(
+		weightMsgArweave,
+		sequencersimulation.SimulateMsgArweave(am.accountKeeper, am.bankKeeper, am.keeper),
+	))
+
 	// this line is used by starport scaffolding # simapp/module/operation
 
 	return operations

x/sequencer/simulation/arweave.go

@@ -0,0 +1,29 @@
+package simulation
+
+import (
+	"math/rand"
+
+	"github.com/cosmos/cosmos-sdk/baseapp"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	simtypes "github.com/cosmos/cosmos-sdk/types/simulation"
+	"github.com/warp-contracts/sequencer/x/sequencer/keeper"
+	"github.com/warp-contracts/sequencer/x/sequencer/types"
+)
+
+func SimulateMsgArweave(
+	ak types.AccountKeeper,
+	bk types.BankKeeper,
+	k keeper.Keeper,
+) simtypes.Operation {
+	return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accs []simtypes.Account, chainID string,
+	) (simtypes.OperationMsg, []simtypes.FutureOperation, error) {
+		simAccount, _ := simtypes.RandomAcc(r, accs)
+		msg := &types.MsgArweave{
+			Creator: simAccount.Address.String(),
+		}
+
+		// TODO: Handling the Arweave simulation
+
+		return simtypes.NoOpMsg(types.ModuleName, msg.Type(), "Arweave simulation not implemented"), nil, nil
+	}
+}

x/sequencer/types/codec.go

@@ -3,15 +3,19 @@ package types
 import (
 	"github.com/cosmos/cosmos-sdk/codec"
 	cdctypes "github.com/cosmos/cosmos-sdk/codec/types"
-	// this line is used by starport scaffolding # 1
+	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/types/msgservice"
 )
 
 func RegisterCodec(cdc *codec.LegacyAmino) {
+	cdc.RegisterConcrete(&MsgArweave{}, "sequencer/Arweave", nil)
 	// this line is used by starport scaffolding # 2
 }
 
 func RegisterInterfaces(registry cdctypes.InterfaceRegistry) {
+	registry.RegisterImplementations((*sdk.Msg)(nil),
+		&MsgArweave{},
+	)
 	// this line is used by starport scaffolding # 3
 
 	msgservice.RegisterMsgServiceDesc(registry, &_Msg_serviceDesc)