diff --git a/proto/panacea/datapool/v2/tx.proto b/proto/panacea/datapool/v2/tx.proto
index 27da6748..cc603c17 100644
--- a/proto/panacea/datapool/v2/tx.proto
+++ b/proto/panacea/datapool/v2/tx.proto
@@ -24,8 +24,8 @@ service Msg {
   // SellData defines a method for selling data
   rpc SellData(MsgSellData) returns (MsgSellDataResponse);
 
-  // BuyDataAccessNFT defines a method for buying data access NFT
-  rpc BuyDataAccessNFT(MsgBuyDataAccessNFT) returns (MsgBuyDataAccessNFTResponse);
+  // BuyDataPass defines a method for buying data access NFT
+  rpc BuyDataPass(MsgBuyDataPass) returns (MsgBuyDataPassResponse);
 
   // RedeemDataAccessNFT defines a method for redeeming data access NFT to get data
   rpc RedeemDataAccessNFT(MsgRedeemDataAccessNFT) returns (MsgRedeemDataAccessNFTResponse);
@@ -75,16 +75,16 @@ message MsgSellDataResponse {
   cosmos.base.v1beta1.Coin accum_pool_share_token = 1;  // denom: DP-{pood-id}
 }
 
-// MsgBuyDataAccessNFT defines the Msg/BuyDataAccessNFT request type.
-message MsgBuyDataAccessNFT {
+// MsgBuyDataPass defines the Msg/BuyDataPass request type.
+message MsgBuyDataPass {
   uint64                   pool_id = 1;
   uint64                   round = 2;
   cosmos.base.v1beta1.Coin payment = 3;
   string                   buyer = 4;   // 'panacea1' address of buyer
 }
 
-// MsgBuyDataAccessNFTResponse defines the Msg/BuyDataAccessNFT response type.
-message MsgBuyDataAccessNFTResponse {
+// MsgBuyDataPassResponse defines the Msg/BuyDataAccessNFT response type.
+message MsgBuyDataPassResponse {
   uint64 pool_id = 1;
   uint64 round = 2;
   uint64 nft_id = 3;
diff --git a/x/datapool/client/cli/txPool.go b/x/datapool/client/cli/txPool.go
index 0038c36c..d8f41b41 100644
--- a/x/datapool/client/cli/txPool.go
+++ b/x/datapool/client/cli/txPool.go
@@ -206,7 +206,7 @@ func CmdBuyDataAccessNFT() *cobra.Command {
 				return err
 			}
 
-			msg := &types.MsgBuyDataAccessNFT{
+			msg := &types.MsgBuyDataPass{
 				PoolId:  poolID,
 				Round:   round,
 				Payment: &payment,
diff --git a/x/datapool/handler.go b/x/datapool/handler.go
index acc69121..8194e429 100644
--- a/x/datapool/handler.go
+++ b/x/datapool/handler.go
@@ -27,8 +27,8 @@ func NewHandler(k keeper.Keeper) sdk.Handler {
 		case *types.MsgCreatePool:
 			res, err := msgServer.CreatePool(sdk.WrapSDKContext(ctx), msg)
 			return sdk.WrapServiceResult(ctx, res, err)
-		case *types.MsgBuyDataAccessNFT:
-			res, err := msgServer.BuyDataAccessNFT(sdk.WrapSDKContext(ctx), msg)
+		case *types.MsgBuyDataPass:
+			res, err := msgServer.BuyDataPass(sdk.WrapSDKContext(ctx), msg)
 			return sdk.WrapServiceResult(ctx, res, err)
 		case *types.MsgSellData:
 			res, err := msgServer.SellData(sdk.WrapSDKContext(ctx), msg)
diff --git a/x/datapool/keeper/msg_server_pool.go b/x/datapool/keeper/msg_server_pool.go
index ef72a003..fb7abe9f 100644
--- a/x/datapool/keeper/msg_server_pool.go
+++ b/x/datapool/keeper/msg_server_pool.go
@@ -74,7 +74,7 @@ func (m msgServer) SellData(goCtx context.Context, msg *types.MsgSellData) (*typ
 	}, nil
 }
 
-func (m msgServer) BuyDataAccessNFT(goCtx context.Context, msg *types.MsgBuyDataAccessNFT) (*types.MsgBuyDataAccessNFTResponse, error) {
+func (m msgServer) BuyDataPass(goCtx context.Context, msg *types.MsgBuyDataPass) (*types.MsgBuyDataPassResponse, error) {
 	ctx := sdk.UnwrapSDKContext(goCtx)
 
 	buyer, err := sdk.AccAddressFromBech32(msg.Buyer)
@@ -82,12 +82,12 @@ func (m msgServer) BuyDataAccessNFT(goCtx context.Context, msg *types.MsgBuyData
 		return nil, err
 	}
 
-	err = m.Keeper.BuyDataAccessNFT(ctx, buyer, msg.PoolId, msg.Round, *msg.Payment)
+	err = m.Keeper.BuyDataPass(ctx, buyer, msg.PoolId, msg.Round, *msg.Payment)
 	if err != nil {
 		return nil, err
 	}
 
-	return &types.MsgBuyDataAccessNFTResponse{PoolId: msg.PoolId, Round: msg.Round}, nil
+	return &types.MsgBuyDataPassResponse{PoolId: msg.PoolId, Round: msg.Round}, nil
 }
 
 func (m msgServer) RedeemDataAccessNFT(goCtx context.Context, msg *types.MsgRedeemDataAccessNFT) (*types.MsgRedeemDataAccessNFTResponse, error) {
diff --git a/x/datapool/keeper/pool.go b/x/datapool/keeper/pool.go
index 9d82ccff..78e37755 100644
--- a/x/datapool/keeper/pool.go
+++ b/x/datapool/keeper/pool.go
@@ -485,7 +485,7 @@ func (k Keeper) GetDataValidationCertificate(ctx sdk.Context, poolID, round uint
 	return cert, nil
 }
 
-func (k Keeper) BuyDataAccessNFT(ctx sdk.Context, buyer sdk.AccAddress, poolID, round uint64, payment sdk.Coin) error {
+func (k Keeper) BuyDataPass(ctx sdk.Context, buyer sdk.AccAddress, poolID, round uint64, payment sdk.Coin) error {
 	pool, err := k.GetPool(ctx, poolID)
 	if err != nil {
 		return sdkerrors.Wrapf(types.ErrBuyDataPass, err.Error())
diff --git a/x/datapool/keeper/pool_test.go b/x/datapool/keeper/pool_test.go
index 145aafe1..09afdded 100644
--- a/x/datapool/keeper/pool_test.go
+++ b/x/datapool/keeper/pool_test.go
@@ -293,7 +293,7 @@ func (suite poolTestSuite) TestBuyDataAccessNFTPending() {
 	err := suite.BankKeeper.AddCoins(suite.Ctx, buyerAddr, fundForBuyer)
 	suite.Require().NoError(err)
 
-	err = suite.DataPoolKeeper.BuyDataAccessNFT(suite.Ctx, buyerAddr, poolID, 1, NFTPrice)
+	err = suite.DataPoolKeeper.BuyDataPass(suite.Ctx, buyerAddr, poolID, 1, NFTPrice)
 	suite.Require().NoError(err)
 
 	pool, err := suite.DataPoolKeeper.GetPool(suite.Ctx, poolID)
@@ -312,7 +312,7 @@ func (suite poolTestSuite) TestBuyDataAccessNFTPoolNotFound() {
 	suite.Require().NoError(err)
 
 	// buy NFT other data pool
-	err = suite.DataPoolKeeper.BuyDataAccessNFT(suite.Ctx, buyerAddr, 2, 1, NFTPrice)
+	err = suite.DataPoolKeeper.BuyDataPass(suite.Ctx, buyerAddr, 2, 1, NFTPrice)
 	suite.Require().Error(err, types.ErrPoolNotFound)
 }
 
@@ -324,11 +324,11 @@ func (suite poolTestSuite) TestBuyDataAccessNFTSoldOut() {
 	suite.Require().NoError(err)
 
 	// buy 1 NFT
-	err = suite.DataPoolKeeper.BuyDataAccessNFT(suite.Ctx, buyerAddr, poolID, 1, NFTPrice)
+	err = suite.DataPoolKeeper.BuyDataPass(suite.Ctx, buyerAddr, poolID, 1, NFTPrice)
 	suite.Require().NoError(err)
 
 	// buy 1 NFT more
-	err = suite.DataPoolKeeper.BuyDataAccessNFT(suite.Ctx, buyerAddr, poolID, 1, NFTPrice)
+	err = suite.DataPoolKeeper.BuyDataPass(suite.Ctx, buyerAddr, poolID, 1, NFTPrice)
 	suite.Require().Error(err, types.ErrNFTAllIssued)
 }
 
@@ -340,7 +340,7 @@ func (suite poolTestSuite) TestBuyDataAccessNFTRoundNotMatched() {
 	suite.Require().NoError(err)
 
 	// different round
-	err = suite.DataPoolKeeper.BuyDataAccessNFT(suite.Ctx, buyerAddr, poolID, 2, NFTPrice)
+	err = suite.DataPoolKeeper.BuyDataPass(suite.Ctx, buyerAddr, poolID, 2, NFTPrice)
 	suite.Require().Error(err, types.ErrRoundNotMatched)
 }
 
@@ -352,7 +352,7 @@ func (suite poolTestSuite) TestBuyDataAccessNFTPaymentNotMatched() {
 	suite.Require().NoError(err)
 
 	// buy NFT with different payment
-	err = suite.DataPoolKeeper.BuyDataAccessNFT(suite.Ctx, buyerAddr, poolID, 1, sdk.NewCoin(assets.MicroMedDenom, sdk.NewInt(5000000)))
+	err = suite.DataPoolKeeper.BuyDataPass(suite.Ctx, buyerAddr, poolID, 1, sdk.NewCoin(assets.MicroMedDenom, sdk.NewInt(5000000)))
 	suite.Require().Error(err, types.ErrPaymentNotMatched)
 }
 
@@ -364,7 +364,7 @@ func (suite poolTestSuite) TestBuyDataAccessNFTInsufficientBalance() {
 	err := suite.BankKeeper.AddCoins(suite.Ctx, buyerAddr, sdk.NewCoins(sdk.NewCoin(assets.MicroMedDenom, sdk.NewInt(1000))))
 	suite.Require().NoError(err)
 
-	err = suite.DataPoolKeeper.BuyDataAccessNFT(suite.Ctx, buyerAddr, poolID, 1, NFTPrice)
+	err = suite.DataPoolKeeper.BuyDataPass(suite.Ctx, buyerAddr, poolID, 1, NFTPrice)
 	suite.Require().Error(err, sdkerrors.ErrInsufficientFunds)
 }
 
diff --git a/x/datapool/types/codec.go b/x/datapool/types/codec.go
index 96fa6a2d..b00b28db 100644
--- a/x/datapool/types/codec.go
+++ b/x/datapool/types/codec.go
@@ -14,7 +14,7 @@ func RegisterCodec(cdc *codec.LegacyAmino) {
 	cdc.RegisterConcrete(&MsgUpdateDataValidator{}, "datapool/UpdateDataValidator", nil)
 	cdc.RegisterConcrete(&MsgCreatePool{}, "datapool/CreatePool", nil)
 	cdc.RegisterConcrete(&MsgSellData{}, "datapool/SellData", nil)
-	cdc.RegisterConcrete(&MsgBuyDataAccessNFT{}, "datapool/BuyDataAccessNFT", nil)
+	cdc.RegisterConcrete(&MsgBuyDataPass{}, "datapool/BuyDataPass", nil)
 	cdc.RegisterConcrete(&MsgRedeemDataAccessNFT{}, "datapool/RedeemDataAccessNFT", nil)
 }
 
@@ -24,7 +24,7 @@ func RegisterInterfaces(registry cdctypes.InterfaceRegistry) {
 		&MsgUpdateDataValidator{},
 		&MsgCreatePool{},
 		&MsgSellData{},
-		&MsgBuyDataAccessNFT{},
+		&MsgBuyDataPass{},
 		&MsgRedeemDataAccessNFT{},
 	)
 	msgservice.RegisterMsgServiceDesc(registry, &_Msg_serviceDesc)
diff --git a/x/datapool/types/message_pool.go b/x/datapool/types/message_pool.go
index 8cdf8383..cedb5289 100644
--- a/x/datapool/types/message_pool.go
+++ b/x/datapool/types/message_pool.go
@@ -213,17 +213,17 @@ func (msg *MsgSellData) GetSigners() []sdk.AccAddress {
 	return []sdk.AccAddress{seller}
 }
 
-var _ sdk.Msg = &MsgBuyDataAccessNFT{}
+var _ sdk.Msg = &MsgBuyDataPass{}
 
-func (msg *MsgBuyDataAccessNFT) Route() string {
+func (msg *MsgBuyDataPass) Route() string {
 	return RouterKey
 }
 
-func (msg *MsgBuyDataAccessNFT) Type() string {
-	return "BuyDataAccessNFT"
+func (msg *MsgBuyDataPass) Type() string {
+	return "BuyDataPass"
 }
 
-func (msg *MsgBuyDataAccessNFT) ValidateBasic() error {
+func (msg *MsgBuyDataPass) ValidateBasic() error {
 	_, err := sdk.AccAddressFromBech32(msg.Buyer)
 	if err != nil {
 		return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid buyer address (%s)", err)
@@ -236,12 +236,12 @@ func (msg *MsgBuyDataAccessNFT) ValidateBasic() error {
 	return nil
 }
 
-func (msg *MsgBuyDataAccessNFT) GetSignBytes() []byte {
+func (msg *MsgBuyDataPass) GetSignBytes() []byte {
 	bz := ModuleCdc.MustMarshalJSON(msg)
 	return sdk.MustSortJSON(bz)
 }
 
-func (msg *MsgBuyDataAccessNFT) GetSigners() []sdk.AccAddress {
+func (msg *MsgBuyDataPass) GetSigners() []sdk.AccAddress {
 	buyer, err := sdk.AccAddressFromBech32(msg.Buyer)
 	if err != nil {
 		panic(err)
diff --git a/x/datapool/types/tx.pb.go b/x/datapool/types/tx.pb.go
index 4a8b36e7..7d891695 100644
--- a/x/datapool/types/tx.pb.go
+++ b/x/datapool/types/tx.pb.go
@@ -414,26 +414,26 @@ func (m *MsgSellDataResponse) GetAccumPoolShareToken() *types.Coin {
 	return nil
 }
 
-// MsgBuyDataAccessNFT defines the Msg/BuyDataAccessNFT request type.
-type MsgBuyDataAccessNFT struct {
+// MsgBuyDataPass defines the Msg/BuyDataPass request type.
+type MsgBuyDataPass struct {
 	PoolId  uint64      `protobuf:"varint,1,opt,name=pool_id,json=poolId,proto3" json:"pool_id,omitempty"`
 	Round   uint64      `protobuf:"varint,2,opt,name=round,proto3" json:"round,omitempty"`
 	Payment *types.Coin `protobuf:"bytes,3,opt,name=payment,proto3" json:"payment,omitempty"`
 	Buyer   string      `protobuf:"bytes,4,opt,name=buyer,proto3" json:"buyer,omitempty"`
 }
 
-func (m *MsgBuyDataAccessNFT) Reset()         { *m = MsgBuyDataAccessNFT{} }
-func (m *MsgBuyDataAccessNFT) String() string { return proto.CompactTextString(m) }
-func (*MsgBuyDataAccessNFT) ProtoMessage()    {}
-func (*MsgBuyDataAccessNFT) Descriptor() ([]byte, []int) {
+func (m *MsgBuyDataPass) Reset()         { *m = MsgBuyDataPass{} }
+func (m *MsgBuyDataPass) String() string { return proto.CompactTextString(m) }
+func (*MsgBuyDataPass) ProtoMessage()    {}
+func (*MsgBuyDataPass) Descriptor() ([]byte, []int) {
 	return fileDescriptor_eb3d400cb0e531d6, []int{8}
 }
-func (m *MsgBuyDataAccessNFT) XXX_Unmarshal(b []byte) error {
+func (m *MsgBuyDataPass) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
 }
-func (m *MsgBuyDataAccessNFT) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+func (m *MsgBuyDataPass) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	if deterministic {
-		return xxx_messageInfo_MsgBuyDataAccessNFT.Marshal(b, m, deterministic)
+		return xxx_messageInfo_MsgBuyDataPass.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
 		n, err := m.MarshalToSizedBuffer(b)
@@ -443,65 +443,65 @@ func (m *MsgBuyDataAccessNFT) XXX_Marshal(b []byte, deterministic bool) ([]byte,
 		return b[:n], nil
 	}
 }
-func (m *MsgBuyDataAccessNFT) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_MsgBuyDataAccessNFT.Merge(m, src)
+func (m *MsgBuyDataPass) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MsgBuyDataPass.Merge(m, src)
 }
-func (m *MsgBuyDataAccessNFT) XXX_Size() int {
+func (m *MsgBuyDataPass) XXX_Size() int {
 	return m.Size()
 }
-func (m *MsgBuyDataAccessNFT) XXX_DiscardUnknown() {
-	xxx_messageInfo_MsgBuyDataAccessNFT.DiscardUnknown(m)
+func (m *MsgBuyDataPass) XXX_DiscardUnknown() {
+	xxx_messageInfo_MsgBuyDataPass.DiscardUnknown(m)
 }
 
-var xxx_messageInfo_MsgBuyDataAccessNFT proto.InternalMessageInfo
+var xxx_messageInfo_MsgBuyDataPass proto.InternalMessageInfo
 
-func (m *MsgBuyDataAccessNFT) GetPoolId() uint64 {
+func (m *MsgBuyDataPass) GetPoolId() uint64 {
 	if m != nil {
 		return m.PoolId
 	}
 	return 0
 }
 
-func (m *MsgBuyDataAccessNFT) GetRound() uint64 {
+func (m *MsgBuyDataPass) GetRound() uint64 {
 	if m != nil {
 		return m.Round
 	}
 	return 0
 }
 
-func (m *MsgBuyDataAccessNFT) GetPayment() *types.Coin {
+func (m *MsgBuyDataPass) GetPayment() *types.Coin {
 	if m != nil {
 		return m.Payment
 	}
 	return nil
 }
 
-func (m *MsgBuyDataAccessNFT) GetBuyer() string {
+func (m *MsgBuyDataPass) GetBuyer() string {
 	if m != nil {
 		return m.Buyer
 	}
 	return ""
 }
 
-// MsgBuyDataAccessNFTResponse defines the Msg/BuyDataAccessNFT response type.
-type MsgBuyDataAccessNFTResponse struct {
+// MsgBuyDataPassResponse defines the Msg/BuyDataAccessNFT response type.
+type MsgBuyDataPassResponse struct {
 	PoolId uint64 `protobuf:"varint,1,opt,name=pool_id,json=poolId,proto3" json:"pool_id,omitempty"`
 	Round  uint64 `protobuf:"varint,2,opt,name=round,proto3" json:"round,omitempty"`
 	NftId  uint64 `protobuf:"varint,3,opt,name=nft_id,json=nftId,proto3" json:"nft_id,omitempty"`
 }
 
-func (m *MsgBuyDataAccessNFTResponse) Reset()         { *m = MsgBuyDataAccessNFTResponse{} }
-func (m *MsgBuyDataAccessNFTResponse) String() string { return proto.CompactTextString(m) }
-func (*MsgBuyDataAccessNFTResponse) ProtoMessage()    {}
-func (*MsgBuyDataAccessNFTResponse) Descriptor() ([]byte, []int) {
+func (m *MsgBuyDataPassResponse) Reset()         { *m = MsgBuyDataPassResponse{} }
+func (m *MsgBuyDataPassResponse) String() string { return proto.CompactTextString(m) }
+func (*MsgBuyDataPassResponse) ProtoMessage()    {}
+func (*MsgBuyDataPassResponse) Descriptor() ([]byte, []int) {
 	return fileDescriptor_eb3d400cb0e531d6, []int{9}
 }
-func (m *MsgBuyDataAccessNFTResponse) XXX_Unmarshal(b []byte) error {
+func (m *MsgBuyDataPassResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
 }
-func (m *MsgBuyDataAccessNFTResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+func (m *MsgBuyDataPassResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	if deterministic {
-		return xxx_messageInfo_MsgBuyDataAccessNFTResponse.Marshal(b, m, deterministic)
+		return xxx_messageInfo_MsgBuyDataPassResponse.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
 		n, err := m.MarshalToSizedBuffer(b)
@@ -511,33 +511,33 @@ func (m *MsgBuyDataAccessNFTResponse) XXX_Marshal(b []byte, deterministic bool)
 		return b[:n], nil
 	}
 }
-func (m *MsgBuyDataAccessNFTResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_MsgBuyDataAccessNFTResponse.Merge(m, src)
+func (m *MsgBuyDataPassResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_MsgBuyDataPassResponse.Merge(m, src)
 }
-func (m *MsgBuyDataAccessNFTResponse) XXX_Size() int {
+func (m *MsgBuyDataPassResponse) XXX_Size() int {
 	return m.Size()
 }
-func (m *MsgBuyDataAccessNFTResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_MsgBuyDataAccessNFTResponse.DiscardUnknown(m)
+func (m *MsgBuyDataPassResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_MsgBuyDataPassResponse.DiscardUnknown(m)
 }
 
-var xxx_messageInfo_MsgBuyDataAccessNFTResponse proto.InternalMessageInfo
+var xxx_messageInfo_MsgBuyDataPassResponse proto.InternalMessageInfo
 
-func (m *MsgBuyDataAccessNFTResponse) GetPoolId() uint64 {
+func (m *MsgBuyDataPassResponse) GetPoolId() uint64 {
 	if m != nil {
 		return m.PoolId
 	}
 	return 0
 }
 
-func (m *MsgBuyDataAccessNFTResponse) GetRound() uint64 {
+func (m *MsgBuyDataPassResponse) GetRound() uint64 {
 	if m != nil {
 		return m.Round
 	}
 	return 0
 }
 
-func (m *MsgBuyDataAccessNFTResponse) GetNftId() uint64 {
+func (m *MsgBuyDataPassResponse) GetNftId() uint64 {
 	if m != nil {
 		return m.NftId
 	}
@@ -667,8 +667,8 @@ func init() {
 	proto.RegisterType((*MsgCreatePoolResponse)(nil), "panacea.datapool.v2.MsgCreatePoolResponse")
 	proto.RegisterType((*MsgSellData)(nil), "panacea.datapool.v2.MsgSellData")
 	proto.RegisterType((*MsgSellDataResponse)(nil), "panacea.datapool.v2.MsgSellDataResponse")
-	proto.RegisterType((*MsgBuyDataAccessNFT)(nil), "panacea.datapool.v2.MsgBuyDataAccessNFT")
-	proto.RegisterType((*MsgBuyDataAccessNFTResponse)(nil), "panacea.datapool.v2.MsgBuyDataAccessNFTResponse")
+	proto.RegisterType((*MsgBuyDataPass)(nil), "panacea.datapool.v2.MsgBuyDataPass")
+	proto.RegisterType((*MsgBuyDataPassResponse)(nil), "panacea.datapool.v2.MsgBuyDataPassResponse")
 	proto.RegisterType((*MsgRedeemDataAccessNFT)(nil), "panacea.datapool.v2.MsgRedeemDataAccessNFT")
 	proto.RegisterType((*MsgRedeemDataAccessNFTResponse)(nil), "panacea.datapool.v2.MsgRedeemDataAccessNFTResponse")
 }
@@ -676,54 +676,55 @@ func init() {
 func init() { proto.RegisterFile("panacea/datapool/v2/tx.proto", fileDescriptor_eb3d400cb0e531d6) }
 
 var fileDescriptor_eb3d400cb0e531d6 = []byte{
-	// 748 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x55, 0xdd, 0x4e, 0x3b, 0x45,
-	0x14, 0xa7, 0x52, 0x5a, 0x3c, 0x0d, 0x42, 0xb6, 0x80, 0x75, 0x35, 0x6b, 0xb3, 0x89, 0x86, 0x48,
-	0xd8, 0x95, 0x12, 0xef, 0x15, 0x88, 0x09, 0x31, 0x25, 0x64, 0x41, 0x2e, 0xd4, 0xa4, 0x99, 0xce,
-	0x9e, 0x2e, 0x13, 0xb6, 0x3b, 0x9b, 0x9d, 0x69, 0xa5, 0x26, 0x3e, 0x83, 0x3e, 0x80, 0x0f, 0xe4,
-	0x25, 0x97, 0x5e, 0x1a, 0x78, 0x11, 0x33, 0xd3, 0xdd, 0xa1, 0x95, 0x5d, 0x10, 0xff, 0x77, 0x3d,
-	0x3d, 0xbf, 0x8f, 0x73, 0xe6, 0x9c, 0x99, 0x85, 0x4f, 0x52, 0x92, 0x10, 0x8a, 0xc4, 0x0f, 0x89,
-	0x24, 0x29, 0xe7, 0xb1, 0x3f, 0xed, 0xf9, 0xf2, 0xce, 0x4b, 0x33, 0x2e, 0xb9, 0xd5, 0xce, 0xb3,
-	0x5e, 0x91, 0xf5, 0xa6, 0x3d, 0x7b, 0x3b, 0xe2, 0x11, 0xd7, 0x79, 0x5f, 0xfd, 0x9a, 0x43, 0x6d,
-	0x87, 0x72, 0x31, 0xe6, 0xc2, 0x1f, 0x12, 0x81, 0xfe, 0xf4, 0x70, 0x88, 0x92, 0x1c, 0xfa, 0x94,
-	0xb3, 0xa4, 0xc8, 0x47, 0x9c, 0x47, 0x31, 0xfa, 0x3a, 0x1a, 0x4e, 0x46, 0x7e, 0x38, 0xc9, 0x88,
-	0x64, 0xdc, 0xe4, 0xcb, 0x0a, 0xd1, 0x96, 0x3a, 0xef, 0x32, 0xe8, 0xf4, 0x45, 0x14, 0x60, 0xc4,
-	0x84, 0xc4, 0xec, 0x94, 0x48, 0x72, 0x4d, 0x62, 0x16, 0x12, 0xc9, 0x33, 0xab, 0x0f, 0x5b, 0xd3,
-	0x22, 0x18, 0x84, 0x28, 0x09, 0x8b, 0x3b, 0xb5, 0x6e, 0x6d, 0xaf, 0xd5, 0x73, 0xbd, 0x92, 0x0e,
-	0xbc, 0x25, 0x76, 0xb0, 0x69, 0xb8, 0xa7, 0x9a, 0xea, 0xba, 0xd0, 0xad, 0xb2, 0x0a, 0x50, 0xa4,
-	0x3c, 0x11, 0xe8, 0xfe, 0x08, 0xbb, 0x7d, 0x11, 0x7d, 0x9f, 0x86, 0x44, 0xe2, 0x72, 0x31, 0x9f,
-	0xc1, 0x07, 0xca, 0x6b, 0x60, 0x54, 0x75, 0x29, 0xef, 0x07, 0x1b, 0xe1, 0x12, 0xcc, 0x86, 0x75,
-	0x4c, 0xc2, 0x94, 0xb3, 0x44, 0x76, 0xde, 0xd3, 0x00, 0x13, 0xbb, 0x5d, 0x70, 0xca, 0xc5, 0x8d,
-	0xfd, 0x2d, 0x6c, 0xf4, 0x45, 0x74, 0x92, 0x21, 0x91, 0x78, 0xc1, 0x79, 0x6c, 0x75, 0xa0, 0x49,
-	0xd5, 0x81, 0x1a, 0xbb, 0x22, 0xb4, 0xbe, 0x86, 0x96, 0xea, 0x7b, 0x90, 0x92, 0x8c, 0x8c, 0x85,
-	0xf6, 0x6a, 0xf5, 0x3e, 0x2d, 0x3d, 0x17, 0xa5, 0x74, 0xa1, 0x61, 0x01, 0xa4, 0xe6, 0xb7, 0x9b,
-	0xc0, 0xce, 0x92, 0x59, 0x51, 0x85, 0xf5, 0x21, 0x34, 0xb5, 0x34, 0x0b, 0xb5, 0x69, 0x3d, 0x68,
-	0xa8, 0xf0, 0x2c, 0xb4, 0xb6, 0x61, 0x2d, 0xe3, 0x93, 0x24, 0xd4, 0x6e, 0xf5, 0x60, 0x1e, 0x58,
-	0x9f, 0xc3, 0x26, 0xcd, 0x87, 0x3e, 0x48, 0x46, 0x52, 0xd1, 0x56, 0x75, 0x7e, 0xa3, 0xf8, 0xfb,
-	0x7c, 0x24, 0xcf, 0x42, 0x97, 0x41, 0xab, 0x2f, 0xa2, 0x4b, 0x8c, 0x63, 0xd5, 0xbc, 0x75, 0x0c,
-	0x75, 0x8a, 0x99, 0xcc, 0x27, 0xea, 0xbd, 0x36, 0x51, 0xc6, 0x93, 0x13, 0xcc, 0x24, 0x1b, 0x31,
-	0x4a, 0x24, 0x06, 0x9a, 0x6b, 0xed, 0x42, 0x43, 0x60, 0x1c, 0x63, 0x96, 0x9f, 0x75, 0x1e, 0xb9,
-	0x08, 0xed, 0x05, 0x2b, 0xd3, 0xd8, 0x39, 0xec, 0x12, 0x4a, 0x27, 0xe3, 0x81, 0x6e, 0x4f, 0xdc,
-	0x90, 0x0c, 0x07, 0x92, 0xdf, 0x62, 0x92, 0x17, 0xf1, 0x91, 0x37, 0xdf, 0x76, 0x4f, 0x6d, 0xbb,
-	0x97, 0x6f, 0xbb, 0x77, 0xc2, 0x59, 0x12, 0xb4, 0x35, 0x51, 0x1d, 0xd3, 0xa5, 0xa2, 0x5d, 0x29,
-	0x96, 0xfb, 0x5b, 0x4d, 0xfb, 0x1c, 0x4f, 0x66, 0xca, 0xe6, 0x1b, 0x4a, 0x51, 0x88, 0xf3, 0x6f,
-	0xaf, 0xde, 0x7a, 0x80, 0x47, 0xd0, 0x4c, 0xc9, 0x6c, 0x8c, 0x89, 0xd4, 0x07, 0xf7, 0x62, 0x1d,
-	0x05, 0x52, 0x49, 0x0d, 0x27, 0x33, 0xcc, 0x3a, 0x75, 0xdd, 0xf9, 0x3c, 0x70, 0x29, 0x7c, 0x5c,
-	0x52, 0xd0, 0xff, 0x9d, 0xec, 0x0e, 0x34, 0x96, 0x06, 0xba, 0x96, 0xe8, 0x41, 0xfe, 0xa2, 0x2f,
-	0x49, 0x80, 0x21, 0xe2, 0xf8, 0x9d, 0x1a, 0x2f, 0xd7, 0x57, 0x77, 0x28, 0xd3, 0xe2, 0xa6, 0x3b,
-	0x13, 0xbb, 0xb7, 0xfa, 0x0e, 0x95, 0x78, 0x9b, 0x1e, 0xcf, 0xa0, 0x99, 0x21, 0x45, 0x96, 0x16,
-	0xab, 0xe5, 0x57, 0xae, 0xd6, 0x02, 0x59, 0xe9, 0x05, 0x73, 0x5a, 0x50, 0xf0, 0x7b, 0x7f, 0xac,
-	0xc1, 0x6a, 0x5f, 0x44, 0xd6, 0xaf, 0xb0, 0x53, 0xfe, 0x42, 0x1d, 0x94, 0x4a, 0x57, 0xbd, 0x32,
-	0xf6, 0x57, 0x6f, 0x82, 0x9b, 0x8e, 0x7e, 0x86, 0x76, 0xd9, 0x8b, 0xb4, 0x5f, 0xa5, 0x56, 0x02,
-	0xb6, 0x8f, 0xde, 0x00, 0x36, 0xc6, 0x3f, 0x01, 0x2c, 0xbc, 0x45, 0x6e, 0x95, 0xc4, 0x13, 0xc6,
-	0xfe, 0xe2, 0x75, 0x8c, 0x51, 0xbf, 0x86, 0x75, 0xf3, 0x18, 0x74, 0xab, 0x78, 0x05, 0xc2, 0xde,
-	0x7b, 0x0d, 0x61, 0x74, 0x13, 0xd8, 0x7a, 0x76, 0x23, 0x2b, 0xd9, 0xff, 0x46, 0xda, 0x5f, 0xfe,
-	0x57, 0xe4, 0xe2, 0x78, 0xca, 0xee, 0xc2, 0x7e, 0xf5, 0xb0, 0x9f, 0x81, 0xab, 0xc7, 0xf3, 0xc2,
-	0xa6, 0x1f, 0x7f, 0xf7, 0xe7, 0x83, 0x53, 0xbb, 0x7f, 0x70, 0x6a, 0x7f, 0x3f, 0x38, 0xb5, 0xdf,
-	0x1f, 0x9d, 0x95, 0xfb, 0x47, 0x67, 0xe5, 0xaf, 0x47, 0x67, 0xe5, 0x87, 0xc3, 0x88, 0xc9, 0x9b,
-	0xc9, 0xd0, 0xa3, 0x7c, 0xec, 0x8f, 0x31, 0x64, 0xc3, 0x98, 0x53, 0x3f, 0x77, 0x38, 0xa0, 0x3c,
-	0x43, 0xff, 0xee, 0xe9, 0x83, 0x2c, 0x67, 0x29, 0x8a, 0x61, 0x43, 0x7f, 0x8f, 0x8f, 0xfe, 0x09,
-	0x00, 0x00, 0xff, 0xff, 0x7c, 0xc2, 0xa5, 0x03, 0x3a, 0x08, 0x00, 0x00,
+	// 756 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x55, 0x5f, 0x4f, 0xdb, 0x48,
+	0x10, 0x27, 0x47, 0x48, 0xb8, 0x89, 0x80, 0x93, 0x03, 0x5c, 0xce, 0x3a, 0xf9, 0x22, 0x9f, 0xee,
+	0x84, 0x0e, 0x61, 0x8b, 0xa0, 0x7b, 0xbf, 0x03, 0x54, 0x09, 0x55, 0x41, 0xc8, 0x50, 0x1e, 0xda,
+	0xaa, 0xd1, 0xc6, 0x9e, 0x98, 0x15, 0x8e, 0xd7, 0xf2, 0x6e, 0x52, 0x52, 0xa9, 0x5f, 0xa0, 0x52,
+	0xa5, 0x7e, 0xac, 0x3e, 0xf2, 0xd8, 0xc7, 0x0a, 0xbe, 0x48, 0xb5, 0x1b, 0x7b, 0x49, 0x54, 0x1b,
+	0x4a, 0xd5, 0xb7, 0x4c, 0xe6, 0xf7, 0x67, 0x66, 0x67, 0x76, 0x0d, 0xbf, 0x27, 0x24, 0x26, 0x3e,
+	0x12, 0x37, 0x20, 0x82, 0x24, 0x8c, 0x45, 0xee, 0xb8, 0xe3, 0x8a, 0x2b, 0x27, 0x49, 0x99, 0x60,
+	0x46, 0x33, 0xcb, 0x3a, 0x79, 0xd6, 0x19, 0x77, 0xcc, 0xf5, 0x90, 0x85, 0x4c, 0xe5, 0x5d, 0xf9,
+	0x6b, 0x0a, 0x35, 0x2d, 0x9f, 0xf1, 0x21, 0xe3, 0x6e, 0x9f, 0x70, 0x74, 0xc7, 0xbb, 0x7d, 0x14,
+	0x64, 0xd7, 0xf5, 0x19, 0x8d, 0xf3, 0x7c, 0xc8, 0x58, 0x18, 0xa1, 0xab, 0xa2, 0xfe, 0x68, 0xe0,
+	0x06, 0xa3, 0x94, 0x08, 0xca, 0x74, 0xbe, 0xa8, 0x10, 0x65, 0xa9, 0xf2, 0x36, 0x85, 0x56, 0x97,
+	0x87, 0x1e, 0x86, 0x94, 0x0b, 0x4c, 0x0f, 0x89, 0x20, 0xe7, 0x24, 0xa2, 0x01, 0x11, 0x2c, 0x35,
+	0xba, 0xf0, 0xcb, 0x38, 0x0f, 0x7a, 0x01, 0x0a, 0x42, 0xa3, 0x56, 0xa5, 0x5d, 0xd9, 0x6a, 0x74,
+	0x6c, 0xa7, 0xa0, 0x03, 0x67, 0x8e, 0xed, 0xad, 0x69, 0xee, 0xa1, 0xa2, 0xda, 0x36, 0xb4, 0xcb,
+	0xac, 0x3c, 0xe4, 0x09, 0x8b, 0x39, 0xda, 0x2f, 0x60, 0xb3, 0xcb, 0xc3, 0x67, 0x49, 0x40, 0x04,
+	0xce, 0x17, 0xf3, 0x17, 0xac, 0x4a, 0xaf, 0x9e, 0x56, 0x55, 0xa5, 0xfc, 0xec, 0xad, 0x04, 0x73,
+	0x30, 0x13, 0x96, 0x31, 0x0e, 0x12, 0x46, 0x63, 0xd1, 0xfa, 0x49, 0x01, 0x74, 0x6c, 0xb7, 0xc1,
+	0x2a, 0x16, 0xd7, 0xf6, 0x97, 0xb0, 0xd2, 0xe5, 0xe1, 0x41, 0x8a, 0x44, 0xe0, 0x09, 0x63, 0x91,
+	0xd1, 0x82, 0xba, 0x2f, 0x0f, 0x54, 0xdb, 0xe5, 0xa1, 0xf1, 0x1f, 0x34, 0x64, 0xdf, 0xbd, 0x84,
+	0xa4, 0x64, 0xc8, 0x95, 0x57, 0xa3, 0xf3, 0x47, 0xe1, 0xb9, 0x48, 0xa5, 0x13, 0x05, 0xf3, 0x20,
+	0xd1, 0xbf, 0xed, 0x18, 0x36, 0xe6, 0xcc, 0xf2, 0x2a, 0x8c, 0x5f, 0xa1, 0xae, 0xa4, 0x69, 0xa0,
+	0x4c, 0xab, 0x5e, 0x4d, 0x86, 0x47, 0x81, 0xb1, 0x0e, 0x4b, 0x29, 0x1b, 0xc5, 0x81, 0x72, 0xab,
+	0x7a, 0xd3, 0xc0, 0xf8, 0x1b, 0xd6, 0xfc, 0x6c, 0xe8, 0xbd, 0x78, 0x20, 0x24, 0x6d, 0x51, 0xe5,
+	0x57, 0xf2, 0xbf, 0x8f, 0x07, 0xe2, 0x28, 0xb0, 0x29, 0x34, 0xba, 0x3c, 0x3c, 0xc5, 0x28, 0x92,
+	0xcd, 0x1b, 0xfb, 0x50, 0xf5, 0x31, 0x15, 0xd9, 0x44, 0x9d, 0x87, 0x26, 0x4a, 0x59, 0x7c, 0x80,
+	0xa9, 0xa0, 0x03, 0xea, 0x13, 0x81, 0x9e, 0xe2, 0x1a, 0x9b, 0x50, 0xe3, 0x18, 0x45, 0x98, 0x66,
+	0x67, 0x9d, 0x45, 0x36, 0x42, 0x73, 0xc6, 0x4a, 0x37, 0x76, 0x0c, 0x9b, 0xc4, 0xf7, 0x47, 0xc3,
+	0x9e, 0x6a, 0x8f, 0x5f, 0x90, 0x14, 0x7b, 0x82, 0x5d, 0x62, 0x9c, 0x15, 0xf1, 0x9b, 0x33, 0xdd,
+	0x76, 0x47, 0x6e, 0xbb, 0x93, 0x6d, 0xbb, 0x73, 0xc0, 0x68, 0xec, 0x35, 0x15, 0x51, 0x1e, 0xd3,
+	0xa9, 0xa4, 0x9d, 0x49, 0x96, 0xfd, 0xae, 0x02, 0xab, 0x5d, 0x1e, 0xee, 0x8f, 0x26, 0xd2, 0xe6,
+	0x84, 0x70, 0xfe, 0xd8, 0xb3, 0xdb, 0x83, 0x7a, 0x42, 0x26, 0x43, 0x8c, 0x85, 0x3a, 0xb3, 0x7b,
+	0x4b, 0xc8, 0x91, 0x52, 0xaa, 0x3f, 0x9a, 0x60, 0xda, 0xaa, 0xaa, 0xa6, 0xa7, 0x81, 0xfd, 0x4a,
+	0xad, 0xee, 0x4c, 0x2d, 0xdf, 0x3b, 0xcf, 0x0d, 0xa8, 0xcd, 0x8d, 0x71, 0x29, 0x56, 0xe3, 0x7b,
+	0xa3, 0xf4, 0x3d, 0x0c, 0x10, 0x87, 0xd2, 0xe2, 0x7f, 0xdf, 0x47, 0xce, 0x8f, 0x9f, 0x9c, 0xfd,
+	0x18, 0x7d, 0x79, 0x73, 0x52, 0x25, 0xae, 0x1b, 0xd3, 0xb1, 0x7d, 0xa9, 0x6e, 0x4e, 0x81, 0xb7,
+	0xee, 0xf1, 0x08, 0xea, 0x29, 0xfa, 0x48, 0x93, 0x7c, 0xa1, 0xdc, 0xd2, 0x85, 0x9a, 0x21, 0x4b,
+	0x3d, 0x6f, 0x4a, 0xf3, 0x72, 0x7e, 0xe7, 0xfd, 0x12, 0x2c, 0x76, 0x79, 0x68, 0xbc, 0x85, 0x8d,
+	0xe2, 0x77, 0x69, 0xa7, 0x50, 0xba, 0xec, 0x6d, 0x31, 0xff, 0x7d, 0x14, 0x5c, 0x77, 0xf4, 0x1a,
+	0x9a, 0x45, 0xef, 0xd0, 0x76, 0x99, 0x5a, 0x01, 0xd8, 0xdc, 0x7b, 0x04, 0x58, 0x1b, 0xbf, 0x04,
+	0x98, 0x79, 0x81, 0xec, 0x32, 0x89, 0x3b, 0x8c, 0xf9, 0xcf, 0xc3, 0x18, 0xad, 0x7e, 0x0e, 0xcb,
+	0xfa, 0x09, 0x68, 0x97, 0xf1, 0x72, 0x84, 0xb9, 0xf5, 0x10, 0x42, 0xeb, 0xf6, 0xa0, 0x31, 0x7b,
+	0x0f, 0xff, 0x2c, 0x23, 0xce, 0x80, 0xcc, 0xed, 0x6f, 0x00, 0xcd, 0xce, 0xa3, 0x68, 0xf9, 0xb7,
+	0xcb, 0xa7, 0xfb, 0x15, 0xb8, 0x7c, 0x1e, 0xf7, 0xac, 0xf6, 0xfe, 0xd3, 0x8f, 0x37, 0x56, 0xe5,
+	0xfa, 0xc6, 0xaa, 0x7c, 0xbe, 0xb1, 0x2a, 0x1f, 0x6e, 0xad, 0x85, 0xeb, 0x5b, 0x6b, 0xe1, 0xd3,
+	0xad, 0xb5, 0xf0, 0x7c, 0x37, 0xa4, 0xe2, 0x62, 0xd4, 0x77, 0x7c, 0x36, 0x74, 0x87, 0x18, 0xd0,
+	0x7e, 0xc4, 0x7c, 0x37, 0x73, 0xd8, 0xf1, 0x59, 0x8a, 0xee, 0xd5, 0xdd, 0x77, 0x57, 0x4c, 0x12,
+	0xe4, 0xfd, 0x9a, 0xfa, 0xec, 0xee, 0x7d, 0x09, 0x00, 0x00, 0xff, 0xff, 0xd6, 0xdf, 0xa3, 0xb8,
+	0x21, 0x08, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -746,8 +747,8 @@ type MsgClient interface {
 	CreatePool(ctx context.Context, in *MsgCreatePool, opts ...grpc.CallOption) (*MsgCreatePoolResponse, error)
 	// SellData defines a method for selling data
 	SellData(ctx context.Context, in *MsgSellData, opts ...grpc.CallOption) (*MsgSellDataResponse, error)
-	// BuyDataAccessNFT defines a method for buying data access NFT
-	BuyDataAccessNFT(ctx context.Context, in *MsgBuyDataAccessNFT, opts ...grpc.CallOption) (*MsgBuyDataAccessNFTResponse, error)
+	// BuyDataPass defines a method for buying data access NFT
+	BuyDataPass(ctx context.Context, in *MsgBuyDataPass, opts ...grpc.CallOption) (*MsgBuyDataPassResponse, error)
 	// RedeemDataAccessNFT defines a method for redeeming data access NFT to get data
 	RedeemDataAccessNFT(ctx context.Context, in *MsgRedeemDataAccessNFT, opts ...grpc.CallOption) (*MsgRedeemDataAccessNFTResponse, error)
 }
@@ -796,9 +797,9 @@ func (c *msgClient) SellData(ctx context.Context, in *MsgSellData, opts ...grpc.
 	return out, nil
 }
 
-func (c *msgClient) BuyDataAccessNFT(ctx context.Context, in *MsgBuyDataAccessNFT, opts ...grpc.CallOption) (*MsgBuyDataAccessNFTResponse, error) {
-	out := new(MsgBuyDataAccessNFTResponse)
-	err := c.cc.Invoke(ctx, "/panacea.datapool.v2.Msg/BuyDataAccessNFT", in, out, opts...)
+func (c *msgClient) BuyDataPass(ctx context.Context, in *MsgBuyDataPass, opts ...grpc.CallOption) (*MsgBuyDataPassResponse, error) {
+	out := new(MsgBuyDataPassResponse)
+	err := c.cc.Invoke(ctx, "/panacea.datapool.v2.Msg/BuyDataPass", in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -824,8 +825,8 @@ type MsgServer interface {
 	CreatePool(context.Context, *MsgCreatePool) (*MsgCreatePoolResponse, error)
 	// SellData defines a method for selling data
 	SellData(context.Context, *MsgSellData) (*MsgSellDataResponse, error)
-	// BuyDataAccessNFT defines a method for buying data access NFT
-	BuyDataAccessNFT(context.Context, *MsgBuyDataAccessNFT) (*MsgBuyDataAccessNFTResponse, error)
+	// BuyDataPass defines a method for buying data access NFT
+	BuyDataPass(context.Context, *MsgBuyDataPass) (*MsgBuyDataPassResponse, error)
 	// RedeemDataAccessNFT defines a method for redeeming data access NFT to get data
 	RedeemDataAccessNFT(context.Context, *MsgRedeemDataAccessNFT) (*MsgRedeemDataAccessNFTResponse, error)
 }
@@ -846,8 +847,8 @@ func (*UnimplementedMsgServer) CreatePool(ctx context.Context, req *MsgCreatePoo
 func (*UnimplementedMsgServer) SellData(ctx context.Context, req *MsgSellData) (*MsgSellDataResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method SellData not implemented")
 }
-func (*UnimplementedMsgServer) BuyDataAccessNFT(ctx context.Context, req *MsgBuyDataAccessNFT) (*MsgBuyDataAccessNFTResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method BuyDataAccessNFT not implemented")
+func (*UnimplementedMsgServer) BuyDataPass(ctx context.Context, req *MsgBuyDataPass) (*MsgBuyDataPassResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method BuyDataPass not implemented")
 }
 func (*UnimplementedMsgServer) RedeemDataAccessNFT(ctx context.Context, req *MsgRedeemDataAccessNFT) (*MsgRedeemDataAccessNFTResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method RedeemDataAccessNFT not implemented")
@@ -929,20 +930,20 @@ func _Msg_SellData_Handler(srv interface{}, ctx context.Context, dec func(interf
 	return interceptor(ctx, in, info, handler)
 }
 
-func _Msg_BuyDataAccessNFT_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(MsgBuyDataAccessNFT)
+func _Msg_BuyDataPass_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(MsgBuyDataPass)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
-		return srv.(MsgServer).BuyDataAccessNFT(ctx, in)
+		return srv.(MsgServer).BuyDataPass(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/panacea.datapool.v2.Msg/BuyDataAccessNFT",
+		FullMethod: "/panacea.datapool.v2.Msg/BuyDataPass",
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(MsgServer).BuyDataAccessNFT(ctx, req.(*MsgBuyDataAccessNFT))
+		return srv.(MsgServer).BuyDataPass(ctx, req.(*MsgBuyDataPass))
 	}
 	return interceptor(ctx, in, info, handler)
 }
@@ -986,8 +987,8 @@ var _Msg_serviceDesc = grpc.ServiceDesc{
 			Handler:    _Msg_SellData_Handler,
 		},
 		{
-			MethodName: "BuyDataAccessNFT",
-			Handler:    _Msg_BuyDataAccessNFT_Handler,
+			MethodName: "BuyDataPass",
+			Handler:    _Msg_BuyDataPass_Handler,
 		},
 		{
 			MethodName: "RedeemDataAccessNFT",
@@ -1273,7 +1274,7 @@ func (m *MsgSellDataResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
-func (m *MsgBuyDataAccessNFT) Marshal() (dAtA []byte, err error) {
+func (m *MsgBuyDataPass) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -1283,12 +1284,12 @@ func (m *MsgBuyDataAccessNFT) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *MsgBuyDataAccessNFT) MarshalTo(dAtA []byte) (int, error) {
+func (m *MsgBuyDataPass) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *MsgBuyDataAccessNFT) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *MsgBuyDataPass) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
@@ -1325,7 +1326,7 @@ func (m *MsgBuyDataAccessNFT) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
-func (m *MsgBuyDataAccessNFTResponse) Marshal() (dAtA []byte, err error) {
+func (m *MsgBuyDataPassResponse) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -1335,12 +1336,12 @@ func (m *MsgBuyDataAccessNFTResponse) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *MsgBuyDataAccessNFTResponse) MarshalTo(dAtA []byte) (int, error) {
+func (m *MsgBuyDataPassResponse) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *MsgBuyDataAccessNFTResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *MsgBuyDataPassResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
@@ -1567,7 +1568,7 @@ func (m *MsgSellDataResponse) Size() (n int) {
 	return n
 }
 
-func (m *MsgBuyDataAccessNFT) Size() (n int) {
+func (m *MsgBuyDataPass) Size() (n int) {
 	if m == nil {
 		return 0
 	}
@@ -1590,7 +1591,7 @@ func (m *MsgBuyDataAccessNFT) Size() (n int) {
 	return n
 }
 
-func (m *MsgBuyDataAccessNFTResponse) Size() (n int) {
+func (m *MsgBuyDataPassResponse) Size() (n int) {
 	if m == nil {
 		return 0
 	}
@@ -2378,7 +2379,7 @@ func (m *MsgSellDataResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *MsgBuyDataAccessNFT) Unmarshal(dAtA []byte) error {
+func (m *MsgBuyDataPass) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -2401,10 +2402,10 @@ func (m *MsgBuyDataAccessNFT) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: MsgBuyDataAccessNFT: wiretype end group for non-group")
+			return fmt.Errorf("proto: MsgBuyDataPass: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: MsgBuyDataAccessNFT: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: MsgBuyDataPass: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -2534,7 +2535,7 @@ func (m *MsgBuyDataAccessNFT) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *MsgBuyDataAccessNFTResponse) Unmarshal(dAtA []byte) error {
+func (m *MsgBuyDataPassResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -2557,10 +2558,10 @@ func (m *MsgBuyDataAccessNFTResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: MsgBuyDataAccessNFTResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: MsgBuyDataPassResponse: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: MsgBuyDataAccessNFTResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: MsgBuyDataPassResponse: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1: