ignite scaffold message delete name

Author: nashqueue

docs/static/openapi.yml

@@ -51554,6 +51554,8 @@ definitions:
       the connection handshake.
   nameservice.nameservice.MsgBuyNameResponse:
     type: object
+  nameservice.nameservice.MsgDeleteNameResponse:
+    type: object
   nameservice.nameservice.MsgSetNameResponse:
     type: object
   nameservice.nameservice.Params:

proto/nameservice/tx.proto

@@ -9,6 +9,7 @@ option go_package = "nameservice/x/nameservice/types";
 service Msg {
       rpc BuyName(MsgBuyName) returns (MsgBuyNameResponse);
   rpc SetName(MsgSetName) returns (MsgSetNameResponse);
+  rpc DeleteName(MsgDeleteName) returns (MsgDeleteNameResponse);
 // this line is used by starport scaffolding # proto/tx/rpc
 }
 
@@ -30,4 +31,12 @@ message MsgSetName {
 message MsgSetNameResponse {
 }
 
+message MsgDeleteName {
+  string creator = 1;
+  string name = 2;
+}
+
+message MsgDeleteNameResponse {
+}
+
 // this line is used by starport scaffolding # proto/tx/message

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

@@ -135,18 +135,18 @@ export default {
 		},
 
 
-		async sendMsgBuyName({ rootGetters }, { value, fee = [], memo = '' }) {
+		async sendMsgDeleteName({ rootGetters }, { value, fee = [], memo = '' }) {
 			try {
 				const txClient=await initTxClient(rootGetters)
-				const msg = await txClient.msgBuyName(value)
+				const msg = await txClient.msgDeleteName(value)
 				const result = await txClient.signAndBroadcast([msg], {fee: { amount: fee, 
 	gas: "200000" }, memo})
 				return result
 			} catch (e) {
 				if (e == MissingWalletError) {
-					throw new Error('TxClient:MsgBuyName:Init Could not initialize signing client. Wallet is required.')
+					throw new Error('TxClient:MsgDeleteName:Init Could not initialize signing client. Wallet is required.')
 				}else{
-					throw new Error('TxClient:MsgBuyName:Send Could not broadcast Tx: '+ e.message)
+					throw new Error('TxClient:MsgDeleteName:Send Could not broadcast Tx: '+ e.message)
 				}
 			}
 		},
@@ -165,17 +165,32 @@ export default {
 				}
 			}
 		},
-		
-		async MsgBuyName({ rootGetters }, { value }) {
+		async sendMsgBuyName({ rootGetters }, { value, fee = [], memo = '' }) {
 			try {
 				const txClient=await initTxClient(rootGetters)
 				const msg = await txClient.msgBuyName(value)
-				return msg
+				const result = await txClient.signAndBroadcast([msg], {fee: { amount: fee, 
+	gas: "200000" }, memo})
+				return result
 			} catch (e) {
 				if (e == MissingWalletError) {
 					throw new Error('TxClient:MsgBuyName:Init Could not initialize signing client. Wallet is required.')
+				}else{
+					throw new Error('TxClient:MsgBuyName:Send Could not broadcast Tx: '+ e.message)
+				}
+			}
+		},
+		
+		async MsgDeleteName({ rootGetters }, { value }) {
+			try {
+				const txClient=await initTxClient(rootGetters)
+				const msg = await txClient.msgDeleteName(value)
+				return msg
+			} catch (e) {
+				if (e == MissingWalletError) {
+					throw new Error('TxClient:MsgDeleteName:Init Could not initialize signing client. Wallet is required.')
 				} else{
-					throw new Error('TxClient:MsgBuyName:Create Could not create message: ' + e.message)
+					throw new Error('TxClient:MsgDeleteName:Create Could not create message: ' + e.message)
 				}
 			}
 		},
@@ -192,6 +207,19 @@ export default {
 				}
 			}
 		},
+		async MsgBuyName({ rootGetters }, { value }) {
+			try {
+				const txClient=await initTxClient(rootGetters)
+				const msg = await txClient.msgBuyName(value)
+				return msg
+			} catch (e) {
+				if (e == MissingWalletError) {
+					throw new Error('TxClient:MsgBuyName:Init Could not initialize signing client. Wallet is required.')
+				} else{
+					throw new Error('TxClient:MsgBuyName:Create Could not create message: ' + e.message)
+				}
+			}
+		},
 
 	}
 }

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

@@ -4,13 +4,15 @@ import { StdFee } from "@cosmjs/launchpad";
 import { SigningStargateClient } from "@cosmjs/stargate";
 import { Registry, OfflineSigner, EncodeObject, DirectSecp256k1HdWallet } from "@cosmjs/proto-signing";
 import { Api } from "./rest";
-import { MsgBuyName } from "./types/nameservice/tx";
+import { MsgDeleteName } from "./types/nameservice/tx";
 import { MsgSetName } from "./types/nameservice/tx";
+import { MsgBuyName } from "./types/nameservice/tx";
 
 
 const types = [
-  ["/nameservice.nameservice.MsgBuyName", MsgBuyName],
+  ["/nameservice.nameservice.MsgDeleteName", MsgDeleteName],
   ["/nameservice.nameservice.MsgSetName", MsgSetName],
+  ["/nameservice.nameservice.MsgBuyName", MsgBuyName],
 
 ];
 export const MissingWalletError = new Error("wallet is required");
@@ -43,8 +45,9 @@ const txClient = async (wallet: OfflineSigner, { addr: addr }: TxClientOptions =
 
   return {
     signAndBroadcast: (msgs: EncodeObject[], { fee, memo }: SignAndBroadcastOptions = {fee: defaultFee, memo: ""}) => client.signAndBroadcast(address, msgs, fee,memo),
-    msgBuyName: (data: MsgBuyName): EncodeObject => ({ typeUrl: "/nameservice.nameservice.MsgBuyName", value: MsgBuyName.fromPartial( data ) }),
+    msgDeleteName: (data: MsgDeleteName): EncodeObject => ({ typeUrl: "/nameservice.nameservice.MsgDeleteName", value: MsgDeleteName.fromPartial( data ) }),
     msgSetName: (data: MsgSetName): EncodeObject => ({ typeUrl: "/nameservice.nameservice.MsgSetName", value: MsgSetName.fromPartial( data ) }),
+    msgBuyName: (data: MsgBuyName): EncodeObject => ({ typeUrl: "/nameservice.nameservice.MsgBuyName", value: MsgBuyName.fromPartial( data ) }),
 
   };
 };

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

@@ -11,6 +11,8 @@
 
 export type NameserviceMsgBuyNameResponse = object;
 
+export type NameserviceMsgDeleteNameResponse = object;
+
 export type NameserviceMsgSetNameResponse = object;
 
 /**

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

@@ -19,6 +19,13 @@ export interface MsgSetName {
 
 export interface MsgSetNameResponse {}
 
+export interface MsgDeleteName {
+  creator: string;
+  name: string;
+}
+
+export interface MsgDeleteNameResponse {}
+
 const baseMsgBuyName: object = { creator: "", name: "", bid: "" };
 
 export const MsgBuyName = {
@@ -273,11 +280,122 @@ export const MsgSetNameResponse = {
   },
 };
 
+const baseMsgDeleteName: object = { creator: "", name: "" };
+
+export const MsgDeleteName = {
+  encode(message: MsgDeleteName, writer: Writer = Writer.create()): Writer {
+    if (message.creator !== "") {
+      writer.uint32(10).string(message.creator);
+    }
+    if (message.name !== "") {
+      writer.uint32(18).string(message.name);
+    }
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): MsgDeleteName {
+    const reader = input instanceof Uint8Array ? new Reader(input) : input;
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = { ...baseMsgDeleteName } as MsgDeleteName;
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.creator = reader.string();
+          break;
+        case 2:
+          message.name = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MsgDeleteName {
+    const message = { ...baseMsgDeleteName } as MsgDeleteName;
+    if (object.creator !== undefined && object.creator !== null) {
+      message.creator = String(object.creator);
+    } else {
+      message.creator = "";
+    }
+    if (object.name !== undefined && object.name !== null) {
+      message.name = String(object.name);
+    } else {
+      message.name = "";
+    }
+    return message;
+  },
+
+  toJSON(message: MsgDeleteName): unknown {
+    const obj: any = {};
+    message.creator !== undefined && (obj.creator = message.creator);
+    message.name !== undefined && (obj.name = message.name);
+    return obj;
+  },
+
+  fromPartial(object: DeepPartial<MsgDeleteName>): MsgDeleteName {
+    const message = { ...baseMsgDeleteName } as MsgDeleteName;
+    if (object.creator !== undefined && object.creator !== null) {
+      message.creator = object.creator;
+    } else {
+      message.creator = "";
+    }
+    if (object.name !== undefined && object.name !== null) {
+      message.name = object.name;
+    } else {
+      message.name = "";
+    }
+    return message;
+  },
+};
+
+const baseMsgDeleteNameResponse: object = {};
+
+export const MsgDeleteNameResponse = {
+  encode(_: MsgDeleteNameResponse, writer: Writer = Writer.create()): Writer {
+    return writer;
+  },
+
+  decode(input: Reader | Uint8Array, length?: number): MsgDeleteNameResponse {
+    const reader = input instanceof Uint8Array ? new Reader(input) : input;
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = { ...baseMsgDeleteNameResponse } as MsgDeleteNameResponse;
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(_: any): MsgDeleteNameResponse {
+    const message = { ...baseMsgDeleteNameResponse } as MsgDeleteNameResponse;
+    return message;
+  },
+
+  toJSON(_: MsgDeleteNameResponse): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  fromPartial(_: DeepPartial<MsgDeleteNameResponse>): MsgDeleteNameResponse {
+    const message = { ...baseMsgDeleteNameResponse } as MsgDeleteNameResponse;
+    return message;
+  },
+};
+
 /** Msg defines the Msg service. */
 export interface Msg {
   BuyName(request: MsgBuyName): Promise<MsgBuyNameResponse>;
-  /** this line is used by starport scaffolding # proto/tx/rpc */
   SetName(request: MsgSetName): Promise<MsgSetNameResponse>;
+  /** this line is used by starport scaffolding # proto/tx/rpc */
+  DeleteName(request: MsgDeleteName): Promise<MsgDeleteNameResponse>;
 }
 
 export class MsgClientImpl implements Msg {
@@ -304,6 +422,18 @@ export class MsgClientImpl implements Msg {
     );
     return promise.then((data) => MsgSetNameResponse.decode(new Reader(data)));
   }
+
+  DeleteName(request: MsgDeleteName): Promise<MsgDeleteNameResponse> {
+    const data = MsgDeleteName.encode(request).finish();
+    const promise = this.rpc.request(
+      "nameservice.nameservice.Msg",
+      "DeleteName",
+      data
+    );
+    return promise.then((data) =>
+      MsgDeleteNameResponse.decode(new Reader(data))
+    );
+  }
 }
 
 interface Rpc {

x/nameservice/client/cli/tx.go

@@ -32,6 +32,7 @@ func GetTxCmd() *cobra.Command {
 
 	cmd.AddCommand(CmdBuyName())
 	cmd.AddCommand(CmdSetName())
+	cmd.AddCommand(CmdDeleteName())
 	// this line is used by starport scaffolding # 1
 
 	return cmd

x/nameservice/client/cli/tx_delete_name.go

@@ -0,0 +1,42 @@
+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"
+	"nameservice/x/nameservice/types"
+)
+
+var _ = strconv.Itoa(0)
+
+func CmdDeleteName() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "delete-name [name]",
+		Short: "Broadcast message delete-name",
+		Args:  cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) (err error) {
+			argName := args[0]
+
+			clientCtx, err := client.GetClientTxContext(cmd)
+			if err != nil {
+				return err
+			}
+
+			msg := types.NewMsgDeleteName(
+				clientCtx.GetFromAddress().String(),
+				argName,
+			)
+			if err := msg.ValidateBasic(); err != nil {
+				return err
+			}
+			return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg)
+		},
+	}
+
+	flags.AddTxFlagsToCmd(cmd)
+
+	return cmd
+}

x/nameservice/handler.go

@@ -23,6 +23,9 @@ func NewHandler(k keeper.Keeper) sdk.Handler {
 		case *types.MsgSetName:
 			res, err := msgServer.SetName(sdk.WrapSDKContext(ctx), msg)
 			return sdk.WrapServiceResult(ctx, res, err)
+		case *types.MsgDeleteName:
+			res, err := msgServer.DeleteName(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/nameservice/keeper/msg_server_delete_name.go

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