diff --git a/client/keys.go b/client/keys.go
index 9922e202..df93b5bc 100644
--- a/client/keys.go
+++ b/client/keys.go
@@ -50,13 +50,13 @@ The pass backend requires GnuPG: https://gnupg.org/
 	// support adding Ethereum supported keys
 	addCmd := keys.AddKeyCommand()
 
-	//// update the default signing algorithm value to "eth_secp256k1"
-	//algoFlag := addCmd.Flag("algo")
-	//algoFlag.DefValue = string(hd.EthSecp256k1Type)
-	//err := algoFlag.Value.Set(string(hd.EthSecp256k1Type))
-	//if err != nil {
-	//	panic(err)
-	//}
+	// update the default signing algorithm value to "eth_secp256k1"
+	algoFlag := addCmd.Flag(flags.FlagKeyAlgorithm)
+	algoFlag.DefValue = string(stratoshd.EthSecp256k1Type)
+	err := algoFlag.Value.Set(string(stratoshd.EthSecp256k1Type))
+	if err != nil {
+		panic(err)
+	}
 
 	addCmd.RunE = runAddCmd
 
diff --git a/client/keys/add.go b/client/keys/add.go
index ddc47118..f34862cc 100644
--- a/client/keys/add.go
+++ b/client/keys/add.go
@@ -80,7 +80,7 @@ Example:
 	f.Uint32(flagCoinType, stratos.GetConfig().GetCoinType(), "coin type number for HD derivation")
 	f.Uint32(flagAccount, 0, "Account number for HD derivation")
 	f.Uint32(flagIndex, 0, "Address index number for HD derivation")
-	f.String(flags.FlagKeyAlgorithm, string(hd.Secp256k1Type), "Key signing algorithm to generate keys for")
+	f.String(flags.FlagKeyAlgorithm, string(stratoshd.EthSecp256k1Type), "Key signing algorithm to generate keys for")
 
 	return cmd
 }
diff --git a/proto/stratos/pot/v1/tx.proto b/proto/stratos/pot/v1/tx.proto
index 4cdaade6..e8c324b7 100644
--- a/proto/stratos/pot/v1/tx.proto
+++ b/proto/stratos/pot/v1/tx.proto
@@ -2,10 +2,7 @@ syntax = "proto3";
 package stratos.pot.v1;
 
 import "gogoproto/gogo.proto";
-//import "google/protobuf/any.proto";
 import "google/api/annotations.proto";
-
-//import "cosmos_proto/cosmos.proto";
 import "stratos/pot/v1/pot.proto";
 import "cosmos/base/v1beta1/coin.proto";
 
@@ -20,6 +17,9 @@ service Msg {
   rpc HandleMsgWithdraw(MsgWithdraw) returns (MsgWithdrawResponse) {
     option (google.api.http).post = "/stratos/pot/v1/withdraw";
   };
+  rpc HandleMsgLegacyWithdraw(MsgLegacyWithdraw) returns (MsgLegacyWithdrawResponse) {
+    option (google.api.http).post = "/stratos/pot/v1/legacy_withdraw";
+  };
   rpc HandleMsgFoundationDeposit(MsgFoundationDeposit) returns (MsgFoundationDepositResponse) {
     option (google.api.http).post = "/stratos/pot/v1/foundation_deposit";
   };
@@ -79,6 +79,27 @@ message MsgWithdraw {
 // MsgWithdrawResponse defines the Msg/MsgWithdraw response type.
 message MsgWithdrawResponse {}
 
+// MsgLegacyWithdraw encapsulates an legacyWithdraw transaction as an SDK message.
+message MsgLegacyWithdraw {
+  repeated cosmos.base.v1beta1.Coin amount = 1 [
+    (gogoproto.nullable) = false,
+    (gogoproto.jsontag)  = "amount",
+    (gogoproto.moretags) = "yaml:\"amount\"",
+    (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins"
+  ];
+  string                         from = 2 [
+    (gogoproto.jsontag) = "from",
+    (gogoproto.moretags) = "yaml:\"from\""
+  ];
+  string                         target_address = 3 [
+    (gogoproto.jsontag) = "target_address",
+    (gogoproto.moretags) = "yaml:\"target_address\""
+  ];
+}
+
+// MsgLegacyWithdrawResponse defines the Msg/MsgWithdraw response type.
+message MsgLegacyWithdrawResponse {}
+
 // MsgFoundationDeposit - encapsulates an FoundationDeposit transaction as an SDK message
 message MsgFoundationDeposit {
   repeated cosmos.base.v1beta1.Coin amount = 1 [
diff --git a/x/pot/client/cli/tx.go b/x/pot/client/cli/tx.go
index a1ca7682..a0dc5346 100644
--- a/x/pot/client/cli/tx.go
+++ b/x/pot/client/cli/tx.go
@@ -33,6 +33,7 @@ func NewTxCmd() *cobra.Command {
 	potTxCmd.AddCommand(
 		VolumeReportCmd(),
 		WithdrawCmd(),
+		LegacyWithdrawCmd(),
 		FoundationDepositCmd(),
 		SlashingResourceNodeCmd(),
 	)
@@ -61,11 +62,8 @@ func WithdrawCmd() *cobra.Command {
 		},
 	}
 
-	//cmd.Flags().AddFlagSet(FsAmount)
-	//cmd.Flags().AddFlagSet(FsTargetAddress)
 	cmd.Flags().AddFlagSet(flagSetAmount())
 	cmd.Flags().AddFlagSet(flagSetTargetAddress())
-
 	flags.AddTxFlagsToCmd(cmd)
 
 	_ = cmd.MarkFlagRequired(FlagAmount)
@@ -99,21 +97,75 @@ func buildWithdrawMsg(clientCtx client.Context, txf tx.Factory, fs *flag.FlagSet
 		}
 	}
 
-	//if viper.IsSet(FlagTargetAddress) {
-	//	targetAddressStr := viper.GetString(FlagTargetAddress)
-	//	targetAddress, err = sdk.AccAddressFromBech32(targetAddressStr)
-	//	if err != nil {
-	//		return txf, nil, err
-	//	}
-	//} else {
-	//	targetAddress = walletAddress
-	//}
-
 	msg := types.NewMsgWithdraw(amount, walletAddress, targetAddress)
 
 	return txf, msg, nil
 }
 
+func LegacyWithdrawCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "legacy-withdraw",
+		Short: "withdraw POT reward recorded by legacy wallet address",
+		RunE: func(cmd *cobra.Command, args []string) error {
+			clientCtx, err := client.GetClientTxContext(cmd)
+			if err != nil {
+				return err
+			}
+
+			txf := tx.NewFactoryCLI(clientCtx, cmd.Flags()).
+				WithTxConfig(clientCtx.TxConfig).WithAccountRetriever(clientCtx.AccountRetriever)
+
+			txf, msg, err := buildLegacyWithdrawMsg(clientCtx, txf, cmd.Flags())
+			if err != nil {
+				return err
+			}
+
+			return tx.GenerateOrBroadcastTxWithFactory(clientCtx, txf, msg)
+		},
+	}
+
+	cmd.Flags().AddFlagSet(flagSetAmount())
+	cmd.Flags().AddFlagSet(flagSetTargetAddress())
+	flags.AddTxFlagsToCmd(cmd)
+
+	_ = cmd.MarkFlagRequired(FlagAmount)
+	_ = cmd.MarkFlagRequired(flags.FlagFrom)
+
+	return cmd
+}
+
+// makes a new LegacyWithdrawMsg.
+func buildLegacyWithdrawMsg(clientCtx client.Context, txf tx.Factory, fs *flag.FlagSet) (tx.Factory, *types.MsgLegacyWithdraw, error) {
+	amountStr, err := fs.GetString(FlagAmount)
+	if err != nil {
+		return txf, nil, err
+	}
+	amount, err := sdk.ParseCoinsNormalized(amountStr)
+	if err != nil {
+		return txf, nil, err
+	}
+	from := clientCtx.GetFromAddress()
+
+	targetAddressStr, err := fs.GetString(FlagTargetAddress)
+	if err != nil {
+		return txf, nil, err
+	}
+
+	var targetAddress sdk.AccAddress
+	if targetAddressStr == "" {
+		targetAddress = from
+	} else {
+		targetAddress, err = sdk.AccAddressFromBech32(targetAddressStr)
+		if err != nil {
+			return txf, nil, err
+		}
+	}
+
+	msg := types.NewMsgLegacyWithdraw(amount, from, targetAddress)
+
+	return txf, msg, nil
+}
+
 // VolumeReportCmd will report wallets volume and sign it with the given key.
 func VolumeReportCmd() *cobra.Command {
 	cmd := &cobra.Command{
diff --git a/x/pot/handler.go b/x/pot/handler.go
index 944f44a6..223e1886 100644
--- a/x/pot/handler.go
+++ b/x/pot/handler.go
@@ -19,19 +19,18 @@ func NewHandler(k keeper.Keeper) sdk.Handler {
 		case *types.MsgVolumeReport:
 			res, err := msgServer.HandleMsgVolumeReport(sdk.WrapSDKContext(ctx), msg)
 			return sdk.WrapServiceResult(ctx, res, err)
-			//return handleMsgVolumeReport(ctx, k, msg)
 		case *types.MsgWithdraw:
 			res, err := msgServer.HandleMsgWithdraw(sdk.WrapSDKContext(ctx), msg)
 			return sdk.WrapServiceResult(ctx, res, err)
-			//return handleMsgWithdraw(ctx, k, msg)
+		case *types.MsgLegacyWithdraw:
+			res, err := msgServer.HandleMsgLegacyWithdraw(sdk.WrapSDKContext(ctx), msg)
+			return sdk.WrapServiceResult(ctx, res, err)
 		case *types.MsgFoundationDeposit:
 			res, err := msgServer.HandleMsgFoundationDeposit(sdk.WrapSDKContext(ctx), msg)
 			return sdk.WrapServiceResult(ctx, res, err)
-			//return handleMsgFoundationDeposit(ctx, k, msg)
 		case *types.MsgSlashingResourceNode:
 			res, err := msgServer.HandleMsgSlashingResourceNode(sdk.WrapSDKContext(ctx), msg)
 			return sdk.WrapServiceResult(ctx, res, err)
-			//return handleMsgSlashingResourceNode(ctx, k, msg)
 		default:
 			errMsg := fmt.Sprintf("unrecognized %s message type: %T", types.ModuleName, msg)
 			return nil, sdkerrors.Wrap(sdkerrors.ErrUnknownRequest, errMsg)
diff --git a/x/pot/keeper/msg_server.go b/x/pot/keeper/msg_server.go
index 829da726..91a32d7b 100644
--- a/x/pot/keeper/msg_server.go
+++ b/x/pot/keeper/msg_server.go
@@ -6,7 +6,9 @@ import (
 	"fmt"
 	"strconv"
 
+	"github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1"
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/types/bech32"
 	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 	stratos "github.com/stratosnet/stratos-chain/types"
 	"github.com/stratosnet/stratos-chain/x/pot/types"
@@ -103,6 +105,49 @@ func (k msgServer) HandleMsgWithdraw(goCtx context.Context, msg *types.MsgWithdr
 	return &types.MsgWithdrawResponse{}, nil
 }
 
+func (k msgServer) HandleMsgLegacyWithdraw(goCtx context.Context, msg *types.MsgLegacyWithdraw) (*types.MsgLegacyWithdrawResponse, error) {
+	ctx := sdk.UnwrapSDKContext(goCtx)
+
+	targetAddress, err := sdk.AccAddressFromBech32(msg.TargetAddress)
+	if err != nil {
+		return &types.MsgLegacyWithdrawResponse{}, sdkerrors.Wrap(types.ErrInvalidAddress, err.Error())
+	}
+
+	fromAddress, err := sdk.AccAddressFromBech32(msg.From)
+	if err != nil {
+		return &types.MsgLegacyWithdrawResponse{}, sdkerrors.Wrap(types.ErrInvalidAddress, err.Error())
+	}
+
+	fromAcc := k.AccountKeeper.GetAccount(ctx, fromAddress)
+	pubKey := fromAcc.GetPubKey()
+	legacyPubKey := secp256k1.PubKey{Key: pubKey.Bytes()}
+	legacyWalletAddress := sdk.AccAddress(legacyPubKey.Address().Bytes())
+
+	legacyWalletAddrStr, err := bech32.ConvertAndEncode(stratos.AccountAddressPrefix, legacyWalletAddress.Bytes())
+	if err != nil {
+		return &types.MsgLegacyWithdrawResponse{}, sdkerrors.Wrap(types.ErrLegacyWithdrawFailure, err.Error())
+	}
+
+	err = k.Withdraw(ctx, msg.Amount, legacyWalletAddress, targetAddress)
+	if err != nil {
+		return &types.MsgLegacyWithdrawResponse{}, sdkerrors.Wrap(types.ErrLegacyWithdrawFailure, err.Error())
+	}
+
+	ctx.EventManager().EmitEvents(sdk.Events{
+		sdk.NewEvent(
+			types.EventTypeLegacyWithdraw,
+			sdk.NewAttribute(types.AttributeKeyAmount, msg.Amount.String()),
+			sdk.NewAttribute(types.AttributeKeyLegacyWalletAddress, legacyWalletAddrStr),
+		),
+		sdk.NewEvent(
+			sdk.EventTypeMessage,
+			sdk.NewAttribute(sdk.AttributeKeyModule, types.AttributeValueCategory),
+			sdk.NewAttribute(sdk.AttributeKeySender, msg.From),
+		),
+	})
+	return &types.MsgLegacyWithdrawResponse{}, nil
+}
+
 func (k msgServer) HandleMsgFoundationDeposit(goCtx context.Context, msg *types.MsgFoundationDeposit) (*types.MsgFoundationDepositResponse, error) {
 	ctx := sdk.UnwrapSDKContext(goCtx)
 	from, err := sdk.AccAddressFromBech32(msg.From)
diff --git a/x/pot/types/errors.go b/x/pot/types/errors.go
index c2e06ae7..cf8972ee 100644
--- a/x/pot/types/errors.go
+++ b/x/pot/types/errors.go
@@ -35,6 +35,8 @@ const (
 	codeErrSlashingResourceNodeFailure
 	codeErrRewardDistributionNotComplete
 	codeErrVolumeReport
+	codeErrLegacyAddressNotMatch
+	codeErrLegacyWithdrawFailure
 )
 
 var (
@@ -68,4 +70,6 @@ var (
 	ErrSlashingResourceNodeFailure    = sdkerrors.Register(ModuleName, codeErrSlashingResourceNodeFailure, "failure during slashing resource node")
 	ErrRewardDistributionNotComplete  = sdkerrors.Register(ModuleName, codeErrRewardDistributionNotComplete, "Reward distribution not completed")
 	ErrVolumeReport                   = sdkerrors.Register(ModuleName, codeErrVolumeReport, "volume report failed")
+	ErrLegacyAddressNotMatch          = sdkerrors.Register(ModuleName, codeErrLegacyAddressNotMatch, "public key does not mathe the legacy wallet address")
+	ErrLegacyWithdrawFailure          = sdkerrors.Register(ModuleName, codeErrLegacyWithdrawFailure, "failure during legacyWithdraw")
 )
diff --git a/x/pot/types/events.go b/x/pot/types/events.go
index 31ec597f..db7d245e 100644
--- a/x/pot/types/events.go
+++ b/x/pot/types/events.go
@@ -4,16 +4,18 @@ package types
 const (
 	EventTypeVolumeReport      = "volume_report"
 	EventTypeWithdraw          = "withdraw"
+	EventTypeLegacyWithdraw    = "legacy_withdraw"
 	EventTypeFoundationDeposit = "foundation_deposit"
 	EventTypeSlashing          = "slashing"
 
-	AttributeKeyEpoch            = "epoch"
-	AttributeKeyReportReference  = "report_reference"
-	AttributeKeyAmount           = "amount"
-	AttributeKeyWalletAddress    = "wallet_address"
-	AttributeKeyNodeP2PAddress   = "p2p_address"
-	AttributeKeySlashingNodeType = "slashing_type"
-	AttributeKeyNodeSuspended    = "suspend"
+	AttributeKeyEpoch               = "epoch"
+	AttributeKeyReportReference     = "report_reference"
+	AttributeKeyAmount              = "amount"
+	AttributeKeyWalletAddress       = "wallet_address"
+	AttributeKeyLegacyWalletAddress = "legacy_wallet_address"
+	AttributeKeyNodeP2PAddress      = "p2p_address"
+	AttributeKeySlashingNodeType    = "slashing_type"
+	AttributeKeyNodeSuspended       = "suspend"
 
 	AttributeValueCategory = ModuleName
 )
diff --git a/x/pot/types/msg.go b/x/pot/types/msg.go
index 0ed59e39..f1957636 100644
--- a/x/pot/types/msg.go
+++ b/x/pot/types/msg.go
@@ -8,6 +8,7 @@ import (
 const (
 	VolumeReportMsgType      = "volume_report"
 	WithdrawMsgType          = "withdraw"
+	LegacyWithdrawMsgType    = "legacy_withdraw"
 	FoundationDepositMsgType = "foundation_deposit"
 )
 
@@ -15,6 +16,7 @@ const (
 var (
 	_ sdk.Msg = &MsgVolumeReport{}
 	_ sdk.Msg = &MsgWithdraw{}
+	_ sdk.Msg = &MsgLegacyWithdraw{}
 	_ sdk.Msg = &MsgFoundationDeposit{}
 	_ sdk.Msg = &MsgSlashingResourceNode{}
 )
@@ -166,6 +168,51 @@ func (msg MsgWithdraw) ValidateBasic() error {
 	return nil
 }
 
+func NewMsgLegacyWithdraw(amount sdk.Coins, from sdk.AccAddress, targetAddress sdk.AccAddress) *MsgLegacyWithdraw {
+	return &MsgLegacyWithdraw{
+		Amount:        amount,
+		From:          from.String(),
+		TargetAddress: targetAddress.String(),
+	}
+}
+
+// Route Implement
+func (msg MsgLegacyWithdraw) Route() string { return RouterKey }
+
+// GetSigners Implement
+func (msg MsgLegacyWithdraw) GetSigners() []sdk.AccAddress {
+	var addrs []sdk.AccAddress
+	from, err := sdk.AccAddressFromBech32(msg.From)
+	if err != nil {
+		return addrs
+	}
+	addrs = append(addrs, from)
+	return addrs
+}
+
+// Type Implement
+func (msg MsgLegacyWithdraw) Type() string { return LegacyWithdrawMsgType }
+
+// GetSignBytes gets the bytes for the message signer to sign on
+func (msg MsgLegacyWithdraw) GetSignBytes() []byte {
+	bz := ModuleCdc.MustMarshalJSON(msg)
+	return sdk.MustSortJSON(bz)
+}
+
+// ValidateBasic validity check for the AnteHandler
+func (msg MsgLegacyWithdraw) ValidateBasic() error {
+	if !(msg.Amount.IsValid()) {
+		return ErrWithdrawAmountInvalid
+	}
+	if len(msg.From) == 0 {
+		return ErrEmptyFromAddr
+	}
+	if len(msg.TargetAddress) == 0 {
+		return ErrMissingTargetAddress
+	}
+	return nil
+}
+
 func NewMsgFoundationDeposit(amount sdk.Coins, from sdk.AccAddress) *MsgFoundationDeposit {
 	return &MsgFoundationDeposit{
 		Amount: amount,
diff --git a/x/pot/types/tx.pb.go b/x/pot/types/tx.pb.go
index c4aaeb4d..94df02fc 100644
--- a/x/pot/types/tx.pb.go
+++ b/x/pot/types/tx.pb.go
@@ -244,6 +244,104 @@ func (m *MsgWithdrawResponse) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_MsgWithdrawResponse proto.InternalMessageInfo
 
+// MsgLegacyWithdraw encapsulates an legacyWithdraw transaction as an SDK message.
+type MsgLegacyWithdraw struct {
+	Amount        github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,1,rep,name=amount,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"amount" yaml:"amount"`
+	From          string                                   `protobuf:"bytes,2,opt,name=from,proto3" json:"from" yaml:"from"`
+	TargetAddress string                                   `protobuf:"bytes,3,opt,name=target_address,json=targetAddress,proto3" json:"target_address" yaml:"target_address"`
+}
+
+func (m *MsgLegacyWithdraw) Reset()         { *m = MsgLegacyWithdraw{} }
+func (m *MsgLegacyWithdraw) String() string { return proto.CompactTextString(m) }
+func (*MsgLegacyWithdraw) ProtoMessage()    {}
+func (*MsgLegacyWithdraw) Descriptor() ([]byte, []int) {
+	return fileDescriptor_103c258cace119ca, []int{4}
+}
+func (m *MsgLegacyWithdraw) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *MsgLegacyWithdraw) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_MsgLegacyWithdraw.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *MsgLegacyWithdraw) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MsgLegacyWithdraw.Merge(m, src)
+}
+func (m *MsgLegacyWithdraw) XXX_Size() int {
+	return m.Size()
+}
+func (m *MsgLegacyWithdraw) XXX_DiscardUnknown() {
+	xxx_messageInfo_MsgLegacyWithdraw.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MsgLegacyWithdraw proto.InternalMessageInfo
+
+func (m *MsgLegacyWithdraw) GetAmount() github_com_cosmos_cosmos_sdk_types.Coins {
+	if m != nil {
+		return m.Amount
+	}
+	return nil
+}
+
+func (m *MsgLegacyWithdraw) GetFrom() string {
+	if m != nil {
+		return m.From
+	}
+	return ""
+}
+
+func (m *MsgLegacyWithdraw) GetTargetAddress() string {
+	if m != nil {
+		return m.TargetAddress
+	}
+	return ""
+}
+
+// MsgLegacyWithdrawResponse defines the Msg/MsgWithdraw response type.
+type MsgLegacyWithdrawResponse struct {
+}
+
+func (m *MsgLegacyWithdrawResponse) Reset()         { *m = MsgLegacyWithdrawResponse{} }
+func (m *MsgLegacyWithdrawResponse) String() string { return proto.CompactTextString(m) }
+func (*MsgLegacyWithdrawResponse) ProtoMessage()    {}
+func (*MsgLegacyWithdrawResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_103c258cace119ca, []int{5}
+}
+func (m *MsgLegacyWithdrawResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *MsgLegacyWithdrawResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_MsgLegacyWithdrawResponse.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *MsgLegacyWithdrawResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MsgLegacyWithdrawResponse.Merge(m, src)
+}
+func (m *MsgLegacyWithdrawResponse) XXX_Size() int {
+	return m.Size()
+}
+func (m *MsgLegacyWithdrawResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_MsgLegacyWithdrawResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MsgLegacyWithdrawResponse proto.InternalMessageInfo
+
 // MsgFoundationDeposit - encapsulates an FoundationDeposit transaction as an SDK message
 type MsgFoundationDeposit struct {
 	Amount github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,1,rep,name=amount,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"amount" yaml:"amount"`
@@ -254,7 +352,7 @@ func (m *MsgFoundationDeposit) Reset()         { *m = MsgFoundationDeposit{} }
 func (m *MsgFoundationDeposit) String() string { return proto.CompactTextString(m) }
 func (*MsgFoundationDeposit) ProtoMessage()    {}
 func (*MsgFoundationDeposit) Descriptor() ([]byte, []int) {
-	return fileDescriptor_103c258cace119ca, []int{4}
+	return fileDescriptor_103c258cace119ca, []int{6}
 }
 func (m *MsgFoundationDeposit) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -305,7 +403,7 @@ func (m *MsgFoundationDepositResponse) Reset()         { *m = MsgFoundationDepos
 func (m *MsgFoundationDepositResponse) String() string { return proto.CompactTextString(m) }
 func (*MsgFoundationDepositResponse) ProtoMessage()    {}
 func (*MsgFoundationDepositResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_103c258cace119ca, []int{5}
+	return fileDescriptor_103c258cace119ca, []int{7}
 }
 func (m *MsgFoundationDepositResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -334,7 +432,7 @@ func (m *MsgFoundationDepositResponse) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_MsgFoundationDepositResponse proto.InternalMessageInfo
 
-// MsgRemoveIndexingNode - encapsulates an MsgRemoveIndexingNode transaction as an SDK message
+// MsgRemoveMetaNode - encapsulates an MsgRemoveMetaNode transaction as an SDK message
 type MsgSlashingResourceNode struct {
 	Reporters      []string                                `protobuf:"bytes,1,rep,name=reporters,proto3" json:"reporters" yaml:"reporters"`
 	ReporterOwner  []string                                `protobuf:"bytes,2,rep,name=reporter_owner,json=reporterOwner,proto3" json:"reporter_owner" yaml:"reporter_owner"`
@@ -348,7 +446,7 @@ func (m *MsgSlashingResourceNode) Reset()         { *m = MsgSlashingResourceNode
 func (m *MsgSlashingResourceNode) String() string { return proto.CompactTextString(m) }
 func (*MsgSlashingResourceNode) ProtoMessage()    {}
 func (*MsgSlashingResourceNode) Descriptor() ([]byte, []int) {
-	return fileDescriptor_103c258cace119ca, []int{6}
+	return fileDescriptor_103c258cace119ca, []int{8}
 }
 func (m *MsgSlashingResourceNode) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -420,7 +518,7 @@ func (m *MsgSlashingResourceNodeResponse) Reset()         { *m = MsgSlashingReso
 func (m *MsgSlashingResourceNodeResponse) String() string { return proto.CompactTextString(m) }
 func (*MsgSlashingResourceNodeResponse) ProtoMessage()    {}
 func (*MsgSlashingResourceNodeResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_103c258cace119ca, []int{7}
+	return fileDescriptor_103c258cace119ca, []int{9}
 }
 func (m *MsgSlashingResourceNodeResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -454,6 +552,8 @@ func init() {
 	proto.RegisterType((*MsgVolumeReportResponse)(nil), "stratos.pot.v1.MsgVolumeReportResponse")
 	proto.RegisterType((*MsgWithdraw)(nil), "stratos.pot.v1.MsgWithdraw")
 	proto.RegisterType((*MsgWithdrawResponse)(nil), "stratos.pot.v1.MsgWithdrawResponse")
+	proto.RegisterType((*MsgLegacyWithdraw)(nil), "stratos.pot.v1.MsgLegacyWithdraw")
+	proto.RegisterType((*MsgLegacyWithdrawResponse)(nil), "stratos.pot.v1.MsgLegacyWithdrawResponse")
 	proto.RegisterType((*MsgFoundationDeposit)(nil), "stratos.pot.v1.MsgFoundationDeposit")
 	proto.RegisterType((*MsgFoundationDepositResponse)(nil), "stratos.pot.v1.MsgFoundationDepositResponse")
 	proto.RegisterType((*MsgSlashingResourceNode)(nil), "stratos.pot.v1.MsgSlashingResourceNode")
@@ -463,69 +563,73 @@ func init() {
 func init() { proto.RegisterFile("stratos/pot/v1/tx.proto", fileDescriptor_103c258cace119ca) }
 
 var fileDescriptor_103c258cace119ca = []byte{
-	// 979 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x56, 0x41, 0x6f, 0x1b, 0x45,
-	0x14, 0xce, 0xc6, 0x6e, 0x48, 0x26, 0xb5, 0x53, 0x96, 0x84, 0xb8, 0xa6, 0xf1, 0xb8, 0x43, 0x29,
-	0x86, 0x92, 0x5d, 0x25, 0x1c, 0x90, 0xe0, 0x80, 0x70, 0x11, 0x22, 0xa2, 0x01, 0x69, 0x2d, 0xb5,
-	0xa2, 0x17, 0x6b, 0xed, 0x9d, 0xac, 0x57, 0x5d, 0xcf, 0xac, 0x76, 0xc6, 0x76, 0x7b, 0xe1, 0xc0,
-	0x89, 0x23, 0x12, 0x57, 0xfe, 0x00, 0xdc, 0xf9, 0x05, 0xbd, 0xf4, 0x58, 0x09, 0x0e, 0x88, 0xc3,
-	0x80, 0x12, 0x4e, 0x7b, 0xdc, 0x23, 0x27, 0xe4, 0x99, 0xd9, 0xb5, 0xbd, 0x31, 0x10, 0x94, 0x43,
-	0x4f, 0xf1, 0x7c, 0xdf, 0x7b, 0xdf, 0x7b, 0xfb, 0xf6, 0x9b, 0xb7, 0x01, 0xbb, 0x8c, 0xc7, 0x2e,
-	0xa7, 0xcc, 0x8e, 0x28, 0xb7, 0xc7, 0x07, 0x36, 0x7f, 0x6c, 0x45, 0x31, 0xe5, 0xd4, 0xac, 0x6a,
-	0xc2, 0x8a, 0x28, 0xb7, 0xc6, 0x07, 0xf5, 0x6d, 0x9f, 0xfa, 0x54, 0x52, 0xf6, 0xf4, 0x97, 0x8a,
-	0xaa, 0xdf, 0xf0, 0x29, 0xf5, 0x43, 0x6c, 0xbb, 0x51, 0x60, 0xbb, 0x84, 0x50, 0xee, 0xf2, 0x80,
-	0x12, 0xa6, 0xd9, 0x5a, 0x41, 0x7c, 0x2a, 0xa5, 0x98, 0x46, 0x9f, 0xb2, 0x21, 0x65, 0x76, 0xcf,
-	0x65, 0xd8, 0x1e, 0x1f, 0xf4, 0x30, 0x77, 0x0f, 0xec, 0x3e, 0x0d, 0x88, 0xe2, 0xd1, 0xd3, 0x32,
-	0xd8, 0x3a, 0x66, 0xfe, 0x7d, 0x1a, 0x8e, 0x86, 0xd8, 0xc1, 0x11, 0x8d, 0xb9, 0x39, 0x06, 0xd5,
-	0x89, 0x1b, 0x86, 0x98, 0x77, 0xc7, 0x12, 0x66, 0x35, 0xa3, 0x59, 0x6a, 0x6d, 0x1e, 0x22, 0x6b,
-	0xb1, 0x55, 0xab, 0x13, 0x10, 0x3f, 0xc4, 0x0f, 0x64, 0xac, 0x52, 0x68, 0xdf, 0x49, 0x04, 0x2c,
-	0x64, 0xa7, 0x02, 0xee, 0x3c, 0x71, 0x87, 0xe1, 0xfb, 0x68, 0x11, 0x47, 0x4e, 0x65, 0x32, 0x97,
-	0xca, 0xcc, 0x0f, 0xc0, 0x7a, 0x2c, 0x3b, 0xc0, 0x71, 0x6d, 0xb5, 0x69, 0xb4, 0x36, 0xda, 0x30,
-	0x11, 0x30, 0xc7, 0x52, 0x01, 0xb7, 0x94, 0x4e, 0x86, 0x20, 0x27, 0x27, 0xcd, 0x2f, 0xc1, 0x15,
-	0x1c, 0xd1, 0xfe, 0xa0, 0x56, 0x92, 0x99, 0x77, 0x7f, 0x13, 0xf0, 0xb6, 0x1f, 0xf0, 0xc1, 0xa8,
-	0x67, 0xf5, 0xe9, 0xd0, 0xd6, 0x63, 0x50, 0x7f, 0xf6, 0x99, 0xf7, 0xc8, 0xe6, 0x4f, 0x22, 0xcc,
-	0xac, 0x23, 0xc2, 0x13, 0x01, 0x55, 0x6a, 0x2a, 0xe0, 0x55, 0x55, 0x40, 0x1e, 0x91, 0xa3, 0x60,
-	0xf3, 0x21, 0xb8, 0xa6, 0xca, 0x74, 0x63, 0x7c, 0x82, 0x63, 0x4c, 0xfa, 0xb8, 0x56, 0x96, 0x55,
-	0xec, 0x44, 0xc0, 0x73, 0x5c, 0x2a, 0xe0, 0xee, 0x7c, 0x9f, 0x33, 0x06, 0x39, 0x5b, 0x0a, 0x72,
-	0x32, 0xc4, 0x74, 0x40, 0x35, 0x7b, 0x84, 0x2e, 0x9d, 0x10, 0x1c, 0xd7, 0xae, 0x48, 0x65, 0x39,
-	0xc7, 0x45, 0x66, 0x36, 0xc7, 0x45, 0x1c, 0x39, 0x95, 0x0c, 0xf8, 0x62, 0x7a, 0x36, 0x23, 0x50,
-	0x69, 0xdf, 0xeb, 0x74, 0x59, 0xe0, 0x13, 0x97, 0x8f, 0x62, 0x5c, 0x5b, 0x6b, 0x1a, 0xad, 0xcd,
-	0xc3, 0x66, 0xf1, 0xf5, 0xb5, 0xef, 0x75, 0x3a, 0x59, 0xcc, 0x11, 0x39, 0xa1, 0xed, 0xb7, 0x12,
-	0x01, 0x2b, 0xbd, 0x90, 0xcd, 0x52, 0x53, 0x01, 0xb7, 0x55, 0xcd, 0x05, 0x18, 0x39, 0x57, 0xe7,
-	0x93, 0xd1, 0x75, 0xb0, 0x5b, 0x30, 0x91, 0x83, 0x59, 0x44, 0x09, 0xc3, 0xe8, 0xa7, 0x55, 0xb0,
-	0x79, 0xcc, 0xfc, 0x07, 0x01, 0x1f, 0x78, 0xb1, 0x3b, 0x31, 0xbf, 0x02, 0x6b, 0xee, 0x90, 0x8e,
-	0x08, 0xd7, 0xa6, 0xba, 0x6e, 0xa9, 0x77, 0x62, 0x4d, 0x1d, 0x6a, 0x69, 0x87, 0x5a, 0x77, 0x69,
-	0x40, 0xda, 0x9f, 0x3d, 0x13, 0x70, 0x25, 0x11, 0x50, 0x27, 0xa4, 0x02, 0x56, 0x54, 0x2f, 0xea,
-	0x8c, 0x7e, 0xfc, 0x1d, 0xb6, 0x2e, 0xf0, 0x8a, 0xa7, 0x5a, 0xcc, 0xd1, 0x22, 0xd3, 0x81, 0x6b,
-	0x1b, 0xba, 0x9e, 0x17, 0x63, 0xc6, 0xb4, 0xd5, 0xe6, 0x8d, 0xab, 0x99, 0x73, 0xc6, 0xd5, 0x78,
-	0x6e, 0xdc, 0x8f, 0xd4, 0x79, 0xaa, 0xc9, 0xdd, 0xd8, 0x9f, 0xd3, 0x2c, 0xcd, 0x34, 0x17, 0x99,
-	0x99, 0xe6, 0x22, 0x8e, 0x9c, 0x8a, 0x02, 0xb4, 0x26, 0xda, 0x01, 0xaf, 0xcc, 0x8d, 0x2d, 0x1f,
-	0xe7, 0x53, 0x03, 0x6c, 0x1f, 0x33, 0xff, 0x13, 0x3a, 0x22, 0x9e, 0x5c, 0x01, 0x1f, 0xe3, 0x88,
-	0xb2, 0x80, 0xbf, 0xf0, 0xb9, 0xde, 0x01, 0xe5, 0x93, 0x98, 0x0e, 0xf5, 0x34, 0x77, 0x13, 0x01,
-	0xe5, 0x39, 0x15, 0x70, 0x53, 0x89, 0x4f, 0x4f, 0xc8, 0x91, 0x20, 0x6a, 0x80, 0x1b, 0xcb, 0x1e,
-	0x22, 0x7f, 0xca, 0xbf, 0x4a, 0xd2, 0x50, 0x9d, 0xd0, 0x65, 0x83, 0x80, 0xf8, 0x0e, 0x66, 0x74,
-	0x14, 0xf7, 0xf1, 0xe7, 0xd4, 0xc3, 0xe6, 0x87, 0x60, 0x23, 0xb3, 0xbb, 0x5a, 0x4c, 0x1b, 0xed,
-	0x9b, 0x89, 0x80, 0x33, 0x30, 0x15, 0xf0, 0xda, 0xe2, 0x3d, 0x61, 0xc8, 0x99, 0xd1, 0x4b, 0xae,
-	0xdc, 0xaa, 0x54, 0xb9, 0xcc, 0x95, 0xbb, 0x0f, 0xb6, 0x08, 0xe6, 0x13, 0x1a, 0x3f, 0x2a, 0x58,
-	0x60, 0x3f, 0x11, 0xb0, 0x48, 0xa5, 0x02, 0xbe, 0xaa, 0x54, 0x0b, 0x04, 0x72, 0xaa, 0x1a, 0x99,
-	0x73, 0x56, 0xc1, 0xad, 0xe5, 0x4b, 0xbb, 0x15, 0x83, 0x75, 0xa6, 0x07, 0xab, 0x97, 0xcd, 0xd1,
-	0xff, 0x5a, 0x96, 0x79, 0xf6, 0x6c, 0x21, 0x67, 0x08, 0x72, 0x72, 0xd2, 0x7c, 0x0f, 0xbc, 0xc4,
-	0x46, 0x2c, 0xc2, 0xc4, 0x93, 0xfb, 0x67, 0xbd, 0xbd, 0x97, 0x08, 0x98, 0x41, 0xa9, 0x80, 0x55,
-	0x9d, 0xaa, 0x00, 0xe4, 0x64, 0x14, 0xba, 0x09, 0xe0, 0x3f, 0xbc, 0xfb, 0xcc, 0x1f, 0x87, 0xbf,
-	0x94, 0x41, 0xe9, 0x98, 0xf9, 0xe6, 0x37, 0x06, 0xd8, 0xf9, 0xd4, 0x25, 0x5e, 0x88, 0x8b, 0xdf,
-	0x30, 0x58, 0x5c, 0x76, 0x85, 0x80, 0xfa, 0x9b, 0xff, 0x11, 0x90, 0x7b, 0xf1, 0x8d, 0xaf, 0x7f,
-	0xfe, 0xf3, 0xbb, 0x55, 0x88, 0xf6, 0xec, 0xc2, 0x47, 0x56, 0x7d, 0xc6, 0xba, 0xca, 0x08, 0xe6,
-	0x04, 0xbc, 0x9c, 0x77, 0x92, 0x2f, 0xbb, 0xd7, 0x96, 0x14, 0xc9, 0xc8, 0xfa, 0xeb, 0xff, 0x42,
-	0xe6, 0xd5, 0x9b, 0xb2, 0x7a, 0x1d, 0xd5, 0x8a, 0xd5, 0x27, 0x59, 0x8d, 0xef, 0x0d, 0x50, 0xcf,
-	0x2b, 0x9f, 0xdf, 0x0b, 0xb7, 0x96, 0x54, 0x39, 0x17, 0x55, 0x7f, 0xe7, 0x22, 0x51, 0x79, 0x53,
-	0x6f, 0xcb, 0xa6, 0x6e, 0x21, 0x54, 0x6c, 0xea, 0x24, 0x4f, 0xe9, 0x7a, 0xba, 0xfe, 0x0f, 0x06,
-	0xd8, 0xcb, 0xdb, 0x5b, 0x7a, 0xa1, 0x97, 0xbd, 0x89, 0x65, 0x81, 0x75, 0xfb, 0x82, 0x81, 0x79,
-	0x9f, 0x96, 0xec, 0xb3, 0x85, 0x6e, 0x17, 0xfb, 0xcc, 0x4c, 0xda, 0x8d, 0x75, 0x5a, 0x97, 0x50,
-	0x0f, 0xb7, 0x8f, 0x9e, 0x9d, 0x36, 0x8c, 0xe7, 0xa7, 0x0d, 0xe3, 0x8f, 0xd3, 0x86, 0xf1, 0xed,
-	0x59, 0x63, 0xe5, 0xf9, 0x59, 0x63, 0xe5, 0xd7, 0xb3, 0xc6, 0xca, 0x43, 0x7b, 0xee, 0x76, 0x68,
-	0x2d, 0x82, 0x79, 0xf6, 0x73, 0xbf, 0x3f, 0x70, 0x03, 0x62, 0x3f, 0x96, 0xf2, 0xf2, 0xaa, 0xf4,
-	0xd6, 0xe4, 0xbf, 0x57, 0xef, 0xfe, 0x1d, 0x00, 0x00, 0xff, 0xff, 0xcf, 0x0f, 0x4a, 0x2d, 0xf7,
-	0x09, 0x00, 0x00,
+	// 1042 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x56, 0xcf, 0x6f, 0xdc, 0x44,
+	0x14, 0x8e, 0xf3, 0x8b, 0x64, 0xd2, 0x4d, 0x5a, 0x93, 0x90, 0xcd, 0xb6, 0xd9, 0x49, 0x86, 0xd2,
+	0xa6, 0x94, 0xd8, 0x4a, 0x38, 0x20, 0xc1, 0x01, 0xb1, 0x45, 0x88, 0x88, 0x04, 0x24, 0x47, 0x6a,
+	0x45, 0x2f, 0x2b, 0x67, 0x3d, 0x71, 0xac, 0x7a, 0x67, 0x2c, 0xcf, 0x6c, 0xb6, 0xb9, 0x70, 0xe0,
+	0xc4, 0xb1, 0x12, 0x1c, 0xf9, 0x07, 0xe0, 0xce, 0x5f, 0xd0, 0x4b, 0x8f, 0x95, 0xb8, 0x20, 0x0e,
+	0x03, 0x4a, 0x90, 0x90, 0x7c, 0xf4, 0x91, 0x13, 0xda, 0x99, 0xf1, 0xec, 0xae, 0x77, 0xa1, 0x41,
+	0x15, 0x12, 0x9c, 0x92, 0xf9, 0xbe, 0xf7, 0xbe, 0xf7, 0xf9, 0xf9, 0xcd, 0xf3, 0x82, 0x55, 0xc6,
+	0x53, 0x9f, 0x53, 0xe6, 0x26, 0x94, 0xbb, 0xa7, 0x3b, 0x2e, 0x7f, 0xec, 0x24, 0x29, 0xe5, 0xd4,
+	0x5e, 0xd4, 0x84, 0x93, 0x50, 0xee, 0x9c, 0xee, 0xd4, 0x96, 0x43, 0x1a, 0x52, 0x49, 0xb9, 0xbd,
+	0xff, 0x54, 0x54, 0xed, 0x46, 0x48, 0x69, 0x18, 0x63, 0xd7, 0x4f, 0x22, 0xd7, 0x27, 0x84, 0x72,
+	0x9f, 0x47, 0x94, 0x30, 0xcd, 0x56, 0x4b, 0xe2, 0x3d, 0x29, 0xc5, 0xd4, 0x5b, 0x94, 0xb5, 0x29,
+	0x73, 0x8f, 0x7c, 0x86, 0xdd, 0xd3, 0x9d, 0x23, 0xcc, 0xfd, 0x1d, 0xb7, 0x45, 0x23, 0xa2, 0x78,
+	0xf4, 0x74, 0x1a, 0x2c, 0x1d, 0xb0, 0xf0, 0x3e, 0x8d, 0x3b, 0x6d, 0xec, 0xe1, 0x84, 0xa6, 0xdc,
+	0x3e, 0x05, 0x8b, 0x5d, 0x3f, 0x8e, 0x31, 0x6f, 0x9e, 0x4a, 0x98, 0x55, 0xad, 0x8d, 0xa9, 0xad,
+	0x85, 0x5d, 0xe4, 0x0c, 0x5b, 0x75, 0x0e, 0x23, 0x12, 0xc6, 0xf8, 0x81, 0x8c, 0x55, 0x0a, 0x8d,
+	0xbb, 0x99, 0x80, 0xa5, 0xec, 0x5c, 0xc0, 0x95, 0x33, 0xbf, 0x1d, 0xbf, 0x8b, 0x86, 0x71, 0xe4,
+	0x55, 0xba, 0x03, 0xa9, 0xcc, 0x7e, 0x0f, 0xcc, 0xa5, 0xd2, 0x01, 0x4e, 0xab, 0x93, 0x1b, 0xd6,
+	0xd6, 0x7c, 0x03, 0x66, 0x02, 0x1a, 0x2c, 0x17, 0x70, 0x49, 0xe9, 0x14, 0x08, 0xf2, 0x0c, 0x69,
+	0x7f, 0x0e, 0x66, 0x70, 0x42, 0x5b, 0x27, 0xd5, 0x29, 0x99, 0x79, 0xef, 0x67, 0x01, 0x6f, 0x85,
+	0x11, 0x3f, 0xe9, 0x1c, 0x39, 0x2d, 0xda, 0x76, 0x75, 0x1b, 0xd4, 0x9f, 0x6d, 0x16, 0x3c, 0x72,
+	0xf9, 0x59, 0x82, 0x99, 0xb3, 0x47, 0x78, 0x26, 0xa0, 0x4a, 0xcd, 0x05, 0xbc, 0xa2, 0x0a, 0xc8,
+	0x23, 0xf2, 0x14, 0x6c, 0x3f, 0x04, 0x57, 0x55, 0x99, 0x66, 0x8a, 0x8f, 0x71, 0x8a, 0x49, 0x0b,
+	0x57, 0xa7, 0x65, 0x15, 0x37, 0x13, 0x70, 0x84, 0xcb, 0x05, 0x5c, 0x1d, 0xf4, 0xd9, 0x67, 0x90,
+	0xb7, 0xa4, 0x20, 0xaf, 0x40, 0x6c, 0x0f, 0x2c, 0x16, 0x8f, 0xd0, 0xa4, 0x5d, 0x82, 0xd3, 0xea,
+	0x8c, 0x54, 0x96, 0x7d, 0x1c, 0x66, 0xfa, 0x7d, 0x1c, 0xc6, 0x91, 0x57, 0x29, 0x80, 0xcf, 0x7a,
+	0x67, 0x3b, 0x01, 0x95, 0xc6, 0xfe, 0x61, 0x93, 0x45, 0x21, 0xf1, 0x79, 0x27, 0xc5, 0xd5, 0xd9,
+	0x0d, 0x6b, 0x6b, 0x61, 0x77, 0xa3, 0xfc, 0xfa, 0x1a, 0xfb, 0x87, 0x87, 0x45, 0xcc, 0x1e, 0x39,
+	0xa6, 0x8d, 0x3b, 0x99, 0x80, 0x95, 0xa3, 0x98, 0xf5, 0x53, 0x73, 0x01, 0x97, 0x55, 0xcd, 0x21,
+	0x18, 0x79, 0x57, 0x06, 0x93, 0xd1, 0x1a, 0x58, 0x2d, 0x0d, 0x91, 0x87, 0x59, 0x42, 0x09, 0xc3,
+	0xe8, 0x87, 0x49, 0xb0, 0x70, 0xc0, 0xc2, 0x07, 0x11, 0x3f, 0x09, 0x52, 0xbf, 0x6b, 0x7f, 0x01,
+	0x66, 0xfd, 0x36, 0xed, 0x10, 0xae, 0x87, 0x6a, 0xcd, 0x51, 0xef, 0xc4, 0xe9, 0x4d, 0xa8, 0xa3,
+	0x27, 0xd4, 0xb9, 0x47, 0x23, 0xd2, 0xf8, 0xe4, 0x99, 0x80, 0x13, 0x99, 0x80, 0x3a, 0x21, 0x17,
+	0xb0, 0xa2, 0xbc, 0xa8, 0x33, 0xfa, 0xfe, 0x17, 0xb8, 0x75, 0x89, 0x57, 0xdc, 0xd3, 0x62, 0x9e,
+	0x16, 0xe9, 0x35, 0x5c, 0x8f, 0xa1, 0x1f, 0x04, 0x29, 0x66, 0x4c, 0x8f, 0xda, 0xe0, 0xe0, 0x6a,
+	0x66, 0x64, 0x70, 0x35, 0x6e, 0x06, 0xf7, 0x03, 0x75, 0xee, 0x69, 0x72, 0x3f, 0x0d, 0x07, 0x34,
+	0xa7, 0xfa, 0x9a, 0xc3, 0x4c, 0x5f, 0x73, 0x18, 0x47, 0x5e, 0x45, 0x01, 0x5a, 0x13, 0xad, 0x80,
+	0x57, 0x07, 0xda, 0x66, 0xda, 0xf9, 0xcd, 0x24, 0xb8, 0x76, 0xc0, 0xc2, 0x7d, 0x1c, 0xfa, 0xad,
+	0xb3, 0xff, 0x4c, 0x53, 0xef, 0x82, 0xe9, 0xe3, 0x94, 0xb6, 0x75, 0x2b, 0x57, 0x33, 0x01, 0xe5,
+	0x39, 0x17, 0x70, 0x41, 0x89, 0xf7, 0x4e, 0xc8, 0x93, 0xe0, 0xbf, 0xd2, 0xad, 0xeb, 0x60, 0x6d,
+	0xa4, 0x2b, 0xa6, 0x67, 0x4f, 0x2d, 0xb0, 0x7c, 0xc0, 0xc2, 0x8f, 0x68, 0x87, 0x04, 0x72, 0x6d,
+	0x7e, 0x88, 0x13, 0xca, 0x22, 0xfe, 0xbf, 0x6a, 0x1b, 0xaa, 0x83, 0x1b, 0xe3, 0x1e, 0xc2, 0x3c,
+	0xe5, 0x1f, 0x53, 0xf2, 0x12, 0x1e, 0xc6, 0x3e, 0x3b, 0x89, 0x48, 0xe8, 0x61, 0x46, 0x3b, 0x69,
+	0x0b, 0x7f, 0x4a, 0x03, 0x6c, 0xbf, 0x0f, 0xe6, 0x8b, 0x15, 0xa1, 0x96, 0xf9, 0x7c, 0x63, 0x33,
+	0x13, 0xb0, 0x0f, 0xe6, 0x02, 0x5e, 0x1d, 0xde, 0x2d, 0x0c, 0x79, 0x7d, 0x7a, 0xcc, 0x9a, 0x9a,
+	0x94, 0x2a, 0x2f, 0xb3, 0xa6, 0xee, 0x83, 0x25, 0x82, 0x79, 0x97, 0xa6, 0x8f, 0x4a, 0x83, 0xb0,
+	0x9d, 0x09, 0x58, 0xa6, 0x72, 0x01, 0x5f, 0x53, 0xaa, 0x25, 0x02, 0x79, 0x8b, 0x1a, 0x19, 0xb8,
+	0x8d, 0xa5, 0x1b, 0x3e, 0xfd, 0xd2, 0x37, 0x1c, 0x83, 0x39, 0xa6, 0x1b, 0xab, 0x17, 0xf4, 0xde,
+	0x3f, 0xfa, 0xc0, 0x98, 0xec, 0xfe, 0x47, 0xac, 0x40, 0x90, 0x67, 0x48, 0xfb, 0x1d, 0xf0, 0x0a,
+	0xeb, 0xb0, 0x04, 0x93, 0x40, 0xee, 0xec, 0xb9, 0xc6, 0x7a, 0x26, 0x60, 0x01, 0xe5, 0x02, 0x2e,
+	0xea, 0x54, 0x05, 0x20, 0xaf, 0xa0, 0xd0, 0x26, 0x80, 0x7f, 0xf1, 0xee, 0x8b, 0xf9, 0xd8, 0xfd,
+	0x7d, 0x06, 0x4c, 0x1d, 0xb0, 0xd0, 0xfe, 0xca, 0x02, 0x2b, 0x1f, 0xfb, 0x24, 0x88, 0x71, 0xf9,
+	0xbb, 0x0f, 0xcb, 0x1f, 0x88, 0x52, 0x40, 0xed, 0xf6, 0x0b, 0x02, 0xcc, 0x2c, 0xbe, 0xf1, 0xe5,
+	0x8f, 0xbf, 0x7d, 0x3d, 0x09, 0xd1, 0xba, 0x5b, 0xfa, 0x61, 0xa2, 0x3e, 0xfd, 0x4d, 0x35, 0x08,
+	0x76, 0x17, 0x5c, 0x33, 0x4e, 0xcc, 0x2e, 0xbb, 0x3e, 0xa6, 0x48, 0x41, 0xd6, 0x5e, 0xff, 0x1b,
+	0xd2, 0x54, 0xdf, 0x90, 0xd5, 0x6b, 0xa8, 0x5a, 0xae, 0xde, 0x2d, 0x6a, 0x3c, 0xb1, 0xc0, 0xaa,
+	0xa9, 0x5c, 0xda, 0xa5, 0x9b, 0x63, 0x4a, 0x0c, 0x87, 0xd4, 0xee, 0xbc, 0x30, 0xc4, 0x78, 0xb9,
+	0x2d, 0xbd, 0x6c, 0x22, 0x58, 0xf6, 0x12, 0xcb, 0xf8, 0xa6, 0xb1, 0xf4, 0xad, 0x05, 0x6a, 0xc6,
+	0xd2, 0xe8, 0xaa, 0xba, 0x39, 0xa6, 0xe4, 0x48, 0x54, 0xed, 0xad, 0xcb, 0x44, 0x19, 0x6f, 0x6f,
+	0x4a, 0x6f, 0x37, 0x11, 0x2a, 0x7b, 0x3b, 0x36, 0x29, 0xcd, 0x40, 0xd7, 0xff, 0xce, 0x02, 0xeb,
+	0xc6, 0xde, 0xd8, 0x1d, 0x33, 0x6e, 0x38, 0xc6, 0x05, 0xd6, 0xdc, 0x4b, 0x06, 0x1a, 0x9f, 0x8e,
+	0xf4, 0xb9, 0x85, 0x6e, 0x95, 0x7d, 0x16, 0xf7, 0xa6, 0x99, 0xea, 0xb4, 0x26, 0xa1, 0x01, 0x6e,
+	0xec, 0x3d, 0x3b, 0xaf, 0x5b, 0xcf, 0xcf, 0xeb, 0xd6, 0xaf, 0xe7, 0x75, 0xeb, 0xc9, 0x45, 0x7d,
+	0xe2, 0xf9, 0x45, 0x7d, 0xe2, 0xa7, 0x8b, 0xfa, 0xc4, 0x43, 0x77, 0xe0, 0xc2, 0x6a, 0x2d, 0x82,
+	0x79, 0xf1, 0xef, 0x76, 0xeb, 0xc4, 0x8f, 0x88, 0xfb, 0x58, 0xca, 0xcb, 0xdb, 0x7b, 0x34, 0x2b,
+	0x7f, 0x25, 0xbf, 0xfd, 0x67, 0x00, 0x00, 0x00, 0xff, 0xff, 0x94, 0xd2, 0xe4, 0xc8, 0xbe, 0x0b,
+	0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -542,6 +646,7 @@ const _ = grpc.SupportPackageIsVersion4
 type MsgClient interface {
 	HandleMsgVolumeReport(ctx context.Context, in *MsgVolumeReport, opts ...grpc.CallOption) (*MsgVolumeReportResponse, error)
 	HandleMsgWithdraw(ctx context.Context, in *MsgWithdraw, opts ...grpc.CallOption) (*MsgWithdrawResponse, error)
+	HandleMsgLegacyWithdraw(ctx context.Context, in *MsgLegacyWithdraw, opts ...grpc.CallOption) (*MsgLegacyWithdrawResponse, error)
 	HandleMsgFoundationDeposit(ctx context.Context, in *MsgFoundationDeposit, opts ...grpc.CallOption) (*MsgFoundationDepositResponse, error)
 	HandleMsgSlashingResourceNode(ctx context.Context, in *MsgSlashingResourceNode, opts ...grpc.CallOption) (*MsgSlashingResourceNodeResponse, error)
 }
@@ -572,6 +677,15 @@ func (c *msgClient) HandleMsgWithdraw(ctx context.Context, in *MsgWithdraw, opts
 	return out, nil
 }
 
+func (c *msgClient) HandleMsgLegacyWithdraw(ctx context.Context, in *MsgLegacyWithdraw, opts ...grpc.CallOption) (*MsgLegacyWithdrawResponse, error) {
+	out := new(MsgLegacyWithdrawResponse)
+	err := c.cc.Invoke(ctx, "/stratos.pot.v1.Msg/HandleMsgLegacyWithdraw", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 func (c *msgClient) HandleMsgFoundationDeposit(ctx context.Context, in *MsgFoundationDeposit, opts ...grpc.CallOption) (*MsgFoundationDepositResponse, error) {
 	out := new(MsgFoundationDepositResponse)
 	err := c.cc.Invoke(ctx, "/stratos.pot.v1.Msg/HandleMsgFoundationDeposit", in, out, opts...)
@@ -594,6 +708,7 @@ func (c *msgClient) HandleMsgSlashingResourceNode(ctx context.Context, in *MsgSl
 type MsgServer interface {
 	HandleMsgVolumeReport(context.Context, *MsgVolumeReport) (*MsgVolumeReportResponse, error)
 	HandleMsgWithdraw(context.Context, *MsgWithdraw) (*MsgWithdrawResponse, error)
+	HandleMsgLegacyWithdraw(context.Context, *MsgLegacyWithdraw) (*MsgLegacyWithdrawResponse, error)
 	HandleMsgFoundationDeposit(context.Context, *MsgFoundationDeposit) (*MsgFoundationDepositResponse, error)
 	HandleMsgSlashingResourceNode(context.Context, *MsgSlashingResourceNode) (*MsgSlashingResourceNodeResponse, error)
 }
@@ -608,6 +723,9 @@ func (*UnimplementedMsgServer) HandleMsgVolumeReport(ctx context.Context, req *M
 func (*UnimplementedMsgServer) HandleMsgWithdraw(ctx context.Context, req *MsgWithdraw) (*MsgWithdrawResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method HandleMsgWithdraw not implemented")
 }
+func (*UnimplementedMsgServer) HandleMsgLegacyWithdraw(ctx context.Context, req *MsgLegacyWithdraw) (*MsgLegacyWithdrawResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method HandleMsgLegacyWithdraw not implemented")
+}
 func (*UnimplementedMsgServer) HandleMsgFoundationDeposit(ctx context.Context, req *MsgFoundationDeposit) (*MsgFoundationDepositResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method HandleMsgFoundationDeposit not implemented")
 }
@@ -655,6 +773,24 @@ func _Msg_HandleMsgWithdraw_Handler(srv interface{}, ctx context.Context, dec fu
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Msg_HandleMsgLegacyWithdraw_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(MsgLegacyWithdraw)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MsgServer).HandleMsgLegacyWithdraw(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/stratos.pot.v1.Msg/HandleMsgLegacyWithdraw",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MsgServer).HandleMsgLegacyWithdraw(ctx, req.(*MsgLegacyWithdraw))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 func _Msg_HandleMsgFoundationDeposit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(MsgFoundationDeposit)
 	if err := dec(in); err != nil {
@@ -703,6 +839,10 @@ var _Msg_serviceDesc = grpc.ServiceDesc{
 			MethodName: "HandleMsgWithdraw",
 			Handler:    _Msg_HandleMsgWithdraw_Handler,
 		},
+		{
+			MethodName: "HandleMsgLegacyWithdraw",
+			Handler:    _Msg_HandleMsgLegacyWithdraw_Handler,
+		},
 		{
 			MethodName: "HandleMsgFoundationDeposit",
 			Handler:    _Msg_HandleMsgFoundationDeposit_Handler,
@@ -895,6 +1035,80 @@ func (m *MsgWithdrawResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
+func (m *MsgLegacyWithdraw) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *MsgLegacyWithdraw) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *MsgLegacyWithdraw) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.TargetAddress) > 0 {
+		i -= len(m.TargetAddress)
+		copy(dAtA[i:], m.TargetAddress)
+		i = encodeVarintTx(dAtA, i, uint64(len(m.TargetAddress)))
+		i--
+		dAtA[i] = 0x1a
+	}
+	if len(m.From) > 0 {
+		i -= len(m.From)
+		copy(dAtA[i:], m.From)
+		i = encodeVarintTx(dAtA, i, uint64(len(m.From)))
+		i--
+		dAtA[i] = 0x12
+	}
+	if len(m.Amount) > 0 {
+		for iNdEx := len(m.Amount) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Amount[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintTx(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0xa
+		}
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *MsgLegacyWithdrawResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *MsgLegacyWithdrawResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *MsgLegacyWithdrawResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	return len(dAtA) - i, nil
+}
+
 func (m *MsgFoundationDeposit) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -1149,6 +1363,38 @@ func (m *MsgWithdrawResponse) Size() (n int) {
 	return n
 }
 
+func (m *MsgLegacyWithdraw) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if len(m.Amount) > 0 {
+		for _, e := range m.Amount {
+			l = e.Size()
+			n += 1 + l + sovTx(uint64(l))
+		}
+	}
+	l = len(m.From)
+	if l > 0 {
+		n += 1 + l + sovTx(uint64(l))
+	}
+	l = len(m.TargetAddress)
+	if l > 0 {
+		n += 1 + l + sovTx(uint64(l))
+	}
+	return n
+}
+
+func (m *MsgLegacyWithdrawResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	return n
+}
+
 func (m *MsgFoundationDeposit) Size() (n int) {
 	if m == nil {
 		return 0
@@ -1728,6 +1974,204 @@ func (m *MsgWithdrawResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *MsgLegacyWithdraw) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTx
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: MsgLegacyWithdraw: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: MsgLegacyWithdraw: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTx
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthTx
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthTx
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Amount = append(m.Amount, types.Coin{})
+			if err := m.Amount[len(m.Amount)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field From", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTx
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthTx
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTx
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.From = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field TargetAddress", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTx
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthTx
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTx
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.TargetAddress = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTx(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthTx
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *MsgLegacyWithdrawResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTx
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: MsgLegacyWithdrawResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: MsgLegacyWithdrawResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTx(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthTx
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func (m *MsgFoundationDeposit) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
diff --git a/x/pot/types/tx.pb.gw.go b/x/pot/types/tx.pb.gw.go
index 52ea21eb..5c15af05 100644
--- a/x/pot/types/tx.pb.gw.go
+++ b/x/pot/types/tx.pb.gw.go
@@ -103,6 +103,42 @@ func local_request_Msg_HandleMsgWithdraw_0(ctx context.Context, marshaler runtim
 
 }
 
+var (
+	filter_Msg_HandleMsgLegacyWithdraw_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
+)
+
+func request_Msg_HandleMsgLegacyWithdraw_0(ctx context.Context, marshaler runtime.Marshaler, client MsgClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq MsgLegacyWithdraw
+	var metadata runtime.ServerMetadata
+
+	if err := req.ParseForm(); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Msg_HandleMsgLegacyWithdraw_0); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+
+	msg, err := client.HandleMsgLegacyWithdraw(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+
+}
+
+func local_request_Msg_HandleMsgLegacyWithdraw_0(ctx context.Context, marshaler runtime.Marshaler, server MsgServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq MsgLegacyWithdraw
+	var metadata runtime.ServerMetadata
+
+	if err := req.ParseForm(); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Msg_HandleMsgLegacyWithdraw_0); err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+
+	msg, err := server.HandleMsgLegacyWithdraw(ctx, &protoReq)
+	return msg, metadata, err
+
+}
+
 var (
 	filter_Msg_HandleMsgFoundationDeposit_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
 )
@@ -221,6 +257,26 @@ func RegisterMsgHandlerServer(ctx context.Context, mux *runtime.ServeMux, server
 
 	})
 
+	mux.Handle("POST", pattern_Msg_HandleMsgLegacyWithdraw_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_Msg_HandleMsgLegacyWithdraw_0(rctx, inboundMarshaler, server, req, pathParams)
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Msg_HandleMsgLegacyWithdraw_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
 	mux.Handle("POST", pattern_Msg_HandleMsgFoundationDeposit_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
@@ -342,6 +398,26 @@ func RegisterMsgHandlerClient(ctx context.Context, mux *runtime.ServeMux, client
 
 	})
 
+	mux.Handle("POST", pattern_Msg_HandleMsgLegacyWithdraw_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_Msg_HandleMsgLegacyWithdraw_0(rctx, inboundMarshaler, client, req, pathParams)
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Msg_HandleMsgLegacyWithdraw_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
 	mux.Handle("POST", pattern_Msg_HandleMsgFoundationDeposit_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
@@ -390,6 +466,8 @@ var (
 
 	pattern_Msg_HandleMsgWithdraw_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"stratos", "pot", "v1", "withdraw"}, "", runtime.AssumeColonVerbOpt(true)))
 
+	pattern_Msg_HandleMsgLegacyWithdraw_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"stratos", "pot", "v1", "legacy_withdraw"}, "", runtime.AssumeColonVerbOpt(true)))
+
 	pattern_Msg_HandleMsgFoundationDeposit_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"stratos", "pot", "v1", "foundation_deposit"}, "", runtime.AssumeColonVerbOpt(true)))
 
 	pattern_Msg_HandleMsgSlashingResourceNode_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"stratos", "pot", "v1", "slashing_resource_node"}, "", runtime.AssumeColonVerbOpt(true)))
@@ -400,6 +478,8 @@ var (
 
 	forward_Msg_HandleMsgWithdraw_0 = runtime.ForwardResponseMessage
 
+	forward_Msg_HandleMsgLegacyWithdraw_0 = runtime.ForwardResponseMessage
+
 	forward_Msg_HandleMsgFoundationDeposit_0 = runtime.ForwardResponseMessage
 
 	forward_Msg_HandleMsgSlashingResourceNode_0 = runtime.ForwardResponseMessage