Ignite clie scaffold message commit-scavange

Author: nashqueue

docs/static/openapi.yml

@@ -51552,6 +51552,8 @@ definitions:
     description: |-
       Version defines the versioning scheme used to negotiate the IBC verison in
       the connection handshake.
+  scavenge.scavenge.MsgCommitSolutionResponse:
+    type: object
   scavenge.scavenge.MsgSubmitScavengeResponse:
     type: object
   scavenge.scavenge.Params:

proto/scavenge/tx.proto

@@ -8,6 +8,7 @@ option go_package = "scavenge/x/scavenge/types";
 // Msg defines the Msg service.
 service Msg {
       rpc SubmitScavenge(MsgSubmitScavenge) returns (MsgSubmitScavengeResponse);
+  rpc CommitSolution(MsgCommitSolution) returns (MsgCommitSolutionResponse);
 // this line is used by starport scaffolding # proto/tx/rpc
 }
 
@@ -21,4 +22,13 @@ message MsgSubmitScavenge {
 message MsgSubmitScavengeResponse {
 }
 
+message MsgCommitSolution {
+  string creator = 1;
+  string solutionHash = 2;
+  string solutionScavengerHash = 3;
+}
+
+message MsgCommitSolutionResponse {
+}
+
 // this line is used by starport scaffolding # proto/tx/message

vue/src/store/generated/scavenge/scavenge.scavenge/index.ts

@@ -135,6 +135,21 @@ export default {
 		},
 
 
+		async sendMsgCommitSolution({ rootGetters }, { value, fee = [], memo = '' }) {
+			try {
+				const txClient=await initTxClient(rootGetters)
+				const msg = await txClient.msgCommitSolution(value)
+				const result = await txClient.signAndBroadcast([msg], {fee: { amount: fee, 
+	gas: "200000" }, memo})
+				return result
+			} catch (e) {
+				if (e == MissingWalletError) {
+					throw new Error('TxClient:MsgCommitSolution:Init Could not initialize signing client. Wallet is required.')
+				}else{
+					throw new Error('TxClient:MsgCommitSolution:Send Could not broadcast Tx: '+ e.message)
+				}
+			}
+		},
 		async sendMsgSubmitScavenge({ rootGetters }, { value, fee = [], memo = '' }) {
 			try {
 				const txClient=await initTxClient(rootGetters)
@@ -151,6 +166,19 @@ export default {
 			}
 		},
 
+		async MsgCommitSolution({ rootGetters }, { value }) {
+			try {
+				const txClient=await initTxClient(rootGetters)
+				const msg = await txClient.msgCommitSolution(value)
+				return msg
+			} catch (e) {
+				if (e == MissingWalletError) {
+					throw new Error('TxClient:MsgCommitSolution:Init Could not initialize signing client. Wallet is required.')
+				} else{
+					throw new Error('TxClient:MsgCommitSolution:Create Could not create message: ' + e.message)
+				}
+			}
+		},
 		async MsgSubmitScavenge({ rootGetters }, { value }) {
 			try {
 				const txClient=await initTxClient(rootGetters)

vue/src/store/generated/scavenge/scavenge.scavenge/module/index.ts

@@ -4,10 +4,12 @@ import { StdFee } from "@cosmjs/launchpad";
 import { SigningStargateClient } from "@cosmjs/stargate";
 import { Registry, OfflineSigner, EncodeObject, DirectSecp256k1HdWallet } from "@cosmjs/proto-signing";
 import { Api } from "./rest";
+import { MsgCommitSolution } from "./types/scavenge/tx";
 import { MsgSubmitScavenge } from "./types/scavenge/tx";
 
 
 const types = [
+  ["/scavenge.scavenge.MsgCommitSolution", MsgCommitSolution],
   ["/scavenge.scavenge.MsgSubmitScavenge", MsgSubmitScavenge],
 
 ];
@@ -41,6 +43,7 @@ const txClient = async (wallet: OfflineSigner, { addr: addr }: TxClientOptions =
 
   return {
     signAndBroadcast: (msgs: EncodeObject[], { fee, memo }: SignAndBroadcastOptions = {fee: defaultFee, memo: ""}) => client.signAndBroadcast(address, msgs, fee,memo),
+    msgCommitSolution: (data: MsgCommitSolution): EncodeObject => ({ typeUrl: "/scavenge.scavenge.MsgCommitSolution", value: MsgCommitSolution.fromPartial( data ) }),
     msgSubmitScavenge: (data: MsgSubmitScavenge): EncodeObject => ({ typeUrl: "/scavenge.scavenge.MsgSubmitScavenge", value: MsgSubmitScavenge.fromPartial( data ) }),
 
   };

vue/src/store/generated/scavenge/scavenge.scavenge/module/rest.ts

@@ -20,6 +20,8 @@ export interface RpcStatus {
   details?: ProtobufAny[];
 }
 
+export type ScavengeMsgCommitSolutionResponse = object;
+
 export type ScavengeMsgSubmitScavengeResponse = object;
 
 /**

vue/src/store/generated/scavenge/scavenge.scavenge/module/types/scavenge/tx.ts

@@ -12,6 +12,14 @@ export interface MsgSubmitScavenge {
 
 export interface MsgSubmitScavengeResponse {}
 
+export interface MsgCommitSolution {
+  creator: string;
+  solutionHash: string;
+  solutionScavengerHash: string;
+}
+
+export interface MsgCommitSolutionResponse {}
+
 const baseMsgSubmitScavenge: object = {
   creator: "",
   solutionHash: "",
@@ -177,12 +185,168 @@ export const MsgSubmitScavengeResponse = {
   },
 };
 
+const baseMsgCommitSolution: object = {
+  creator: "",
+  solutionHash: "",
+  solutionScavengerHash: "",
+};
+
+export const MsgCommitSolution = {
+  encode(message: MsgCommitSolution, writer: Writer = Writer.create()): Writer {
+    if (message.creator !== "") {
+      writer.uint32(10).string(message.creator);
+    }
+    if (message.solutionHash !== "") {
+      writer.uint32(18).string(message.solutionHash);
+    }
+    if (message.solutionScavengerHash !== "") {
+      writer.uint32(26).string(message.solutionScavengerHash);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): MsgCommitSolution {
+    const reader = input instanceof Uint8Array ? new Reader(input) : input;
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = { ...baseMsgCommitSolution } as MsgCommitSolution;
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.creator = reader.string();
+          break;
+        case 2:
+          message.solutionHash = reader.string();
+          break;
+        case 3:
+          message.solutionScavengerHash = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MsgCommitSolution {
+    const message = { ...baseMsgCommitSolution } as MsgCommitSolution;
+    if (object.creator !== undefined && object.creator !== null) {
+      message.creator = String(object.creator);
+    } else {
+      message.creator = "";
+    }
+    if (object.solutionHash !== undefined && object.solutionHash !== null) {
+      message.solutionHash = String(object.solutionHash);
+    } else {
+      message.solutionHash = "";
+    }
+    if (
+      object.solutionScavengerHash !== undefined &&
+      object.solutionScavengerHash !== null
+    ) {
+      message.solutionScavengerHash = String(object.solutionScavengerHash);
+    } else {
+      message.solutionScavengerHash = "";
+    }
+    return message;
+  },
+
+  toJSON(message: MsgCommitSolution): unknown {
+    const obj: any = {};
+    message.creator !== undefined && (obj.creator = message.creator);
+    message.solutionHash !== undefined &&
+      (obj.solutionHash = message.solutionHash);
+    message.solutionScavengerHash !== undefined &&
+      (obj.solutionScavengerHash = message.solutionScavengerHash);
+    return obj;
+  },
+
+  fromPartial(object: DeepPartial<MsgCommitSolution>): MsgCommitSolution {
+    const message = { ...baseMsgCommitSolution } as MsgCommitSolution;
+    if (object.creator !== undefined && object.creator !== null) {
+      message.creator = object.creator;
+    } else {
+      message.creator = "";
+    }
+    if (object.solutionHash !== undefined && object.solutionHash !== null) {
+      message.solutionHash = object.solutionHash;
+    } else {
+      message.solutionHash = "";
+    }
+    if (
+      object.solutionScavengerHash !== undefined &&
+      object.solutionScavengerHash !== null
+    ) {
+      message.solutionScavengerHash = object.solutionScavengerHash;
+    } else {
+      message.solutionScavengerHash = "";
+    }
+    return message;
+  },
+};
+
+const baseMsgCommitSolutionResponse: object = {};
+
+export const MsgCommitSolutionResponse = {
+  encode(
+    _: MsgCommitSolutionResponse,
+    writer: Writer = Writer.create()
+  ): Writer {
+    return writer;
+  },
+
+  decode(
+    input: Reader | Uint8Array,
+    length?: number
+  ): MsgCommitSolutionResponse {
+    const reader = input instanceof Uint8Array ? new Reader(input) : input;
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = {
+      ...baseMsgCommitSolutionResponse,
+    } as MsgCommitSolutionResponse;
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(_: any): MsgCommitSolutionResponse {
+    const message = {
+      ...baseMsgCommitSolutionResponse,
+    } as MsgCommitSolutionResponse;
+    return message;
+  },
+
+  toJSON(_: MsgCommitSolutionResponse): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  fromPartial(
+    _: DeepPartial<MsgCommitSolutionResponse>
+  ): MsgCommitSolutionResponse {
+    const message = {
+      ...baseMsgCommitSolutionResponse,
+    } as MsgCommitSolutionResponse;
+    return message;
+  },
+};
+
 /** Msg defines the Msg service. */
 export interface Msg {
-  /** this line is used by starport scaffolding # proto/tx/rpc */
   SubmitScavenge(
     request: MsgSubmitScavenge
   ): Promise<MsgSubmitScavengeResponse>;
+  /** this line is used by starport scaffolding # proto/tx/rpc */
+  CommitSolution(
+    request: MsgCommitSolution
+  ): Promise<MsgCommitSolutionResponse>;
 }
 
 export class MsgClientImpl implements Msg {
@@ -203,6 +367,20 @@ export class MsgClientImpl implements Msg {
       MsgSubmitScavengeResponse.decode(new Reader(data))
     );
   }
+
+  CommitSolution(
+    request: MsgCommitSolution
+  ): Promise<MsgCommitSolutionResponse> {
+    const data = MsgCommitSolution.encode(request).finish();
+    const promise = this.rpc.request(
+      "scavenge.scavenge.Msg",
+      "CommitSolution",
+      data
+    );
+    return promise.then((data) =>
+      MsgCommitSolutionResponse.decode(new Reader(data))
+    );
+  }
 }
 
 interface Rpc {

x/scavenge/client/cli/tx.go

@@ -31,6 +31,7 @@ func GetTxCmd() *cobra.Command {
 	}
 
 	cmd.AddCommand(CmdSubmitScavenge())
+	cmd.AddCommand(CmdCommitSolution())
 	// this line is used by starport scaffolding # 1
 
 	return cmd

x/scavenge/client/cli/tx_commit_solution.go

@@ -0,0 +1,44 @@
+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"
+	"scavenge/x/scavenge/types"
+)
+
+var _ = strconv.Itoa(0)
+
+func CmdCommitSolution() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "commit-solution [solution-hash] [solution-scavenger-hash]",
+		Short: "Broadcast message commit-solution",
+		Args:  cobra.ExactArgs(2),
+		RunE: func(cmd *cobra.Command, args []string) (err error) {
+			argSolutionHash := args[0]
+			argSolutionScavengerHash := args[1]
+
+			clientCtx, err := client.GetClientTxContext(cmd)
+			if err != nil {
+				return err
+			}
+
+			msg := types.NewMsgCommitSolution(
+				clientCtx.GetFromAddress().String(),
+				argSolutionHash,
+				argSolutionScavengerHash,
+			)
+			if err := msg.ValidateBasic(); err != nil {
+				return err
+			}
+			return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg)
+		},
+	}
+
+	flags.AddTxFlagsToCmd(cmd)
+
+	return cmd
+}

x/scavenge/handler.go

@@ -20,6 +20,9 @@ func NewHandler(k keeper.Keeper) sdk.Handler {
 		case *types.MsgSubmitScavenge:
 			res, err := msgServer.SubmitScavenge(sdk.WrapSDKContext(ctx), msg)
 			return sdk.WrapServiceResult(ctx, res, err)
+		case *types.MsgCommitSolution:
+			res, err := msgServer.CommitSolution(sdk.WrapSDKContext(ctx), msg)
+			return sdk.WrapServiceResult(ctx, res, err)
 			// this line is used by starport scaffolding # 1
 		default:
 			errMsg := fmt.Sprintf("unrecognized %s message type: %T", types.ModuleName, msg)

x/scavenge/keeper/msg_server_commit_solution.go

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