github.com/fibonacci-chain/fbc@v0.0.0-20231124064014-c7636198c1e9/x/icamauth/types/tx.pb.go (about)

     1  // Code generated by protoc-gen-gogo. DO NOT EDIT.
     2  // source: gaia/icamauth/v1beta1/tx.proto
     3  
     4  package types
     5  
     6  import (
     7  	context "context"
     8  	fmt "fmt"
     9  	io "io"
    10  	math "math"
    11  	math_bits "math/bits"
    12  
    13  	"github.com/fibonacci-chain/fbc/libs/cosmos-sdk/codec/types"
    14  
    15  	_ "github.com/gogo/protobuf/gogoproto"
    16  	grpc1 "github.com/gogo/protobuf/grpc"
    17  	proto "github.com/gogo/protobuf/proto"
    18  	grpc "google.golang.org/grpc"
    19  	codes "google.golang.org/grpc/codes"
    20  	status "google.golang.org/grpc/status"
    21  )
    22  
    23  // Reference imports to suppress errors if they are not otherwise used.
    24  var _ = proto.Marshal
    25  var _ = fmt.Errorf
    26  var _ = math.Inf
    27  
    28  // This is a compile-time assertion to ensure that this generated file
    29  // is compatible with the proto package it is being compiled against.
    30  // A compilation error at this line likely means your copy of the
    31  // proto package needs to be updated.
    32  const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
    33  
    34  // MsgRegisterAccount defines the payload for Msg/RegisterAccount
    35  type MsgRegisterAccount struct {
    36  	Owner        string `protobuf:"bytes,1,opt,name=owner,proto3" json:"owner,omitempty"`
    37  	ConnectionId string `protobuf:"bytes,2,opt,name=connection_id,json=connectionId,proto3" json:"connection_id,omitempty" yaml:"connection_id"`
    38  	Version      string `protobuf:"bytes,3,opt,name=version,proto3" json:"version,omitempty"`
    39  }
    40  
    41  func (m *MsgRegisterAccount) Reset()         { *m = MsgRegisterAccount{} }
    42  func (m *MsgRegisterAccount) String() string { return proto.CompactTextString(m) }
    43  func (*MsgRegisterAccount) ProtoMessage()    {}
    44  func (*MsgRegisterAccount) Descriptor() ([]byte, []int) {
    45  	return fileDescriptor_a726f12c2143215e, []int{0}
    46  }
    47  func (m *MsgRegisterAccount) XXX_Unmarshal(b []byte) error {
    48  	return m.Unmarshal(b)
    49  }
    50  func (m *MsgRegisterAccount) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    51  	if deterministic {
    52  		return xxx_messageInfo_MsgRegisterAccount.Marshal(b, m, deterministic)
    53  	} else {
    54  		b = b[:cap(b)]
    55  		n, err := m.MarshalToSizedBuffer(b)
    56  		if err != nil {
    57  			return nil, err
    58  		}
    59  		return b[:n], nil
    60  	}
    61  }
    62  func (m *MsgRegisterAccount) XXX_Merge(src proto.Message) {
    63  	xxx_messageInfo_MsgRegisterAccount.Merge(m, src)
    64  }
    65  func (m *MsgRegisterAccount) XXX_Size() int {
    66  	return m.Size()
    67  }
    68  func (m *MsgRegisterAccount) XXX_DiscardUnknown() {
    69  	xxx_messageInfo_MsgRegisterAccount.DiscardUnknown(m)
    70  }
    71  
    72  var xxx_messageInfo_MsgRegisterAccount proto.InternalMessageInfo
    73  
    74  // MsgRegisterAccountResponse defines the response for Msg/RegisterAccount
    75  type MsgRegisterAccountResponse struct {
    76  }
    77  
    78  func (m *MsgRegisterAccountResponse) Reset()         { *m = MsgRegisterAccountResponse{} }
    79  func (m *MsgRegisterAccountResponse) String() string { return proto.CompactTextString(m) }
    80  func (*MsgRegisterAccountResponse) ProtoMessage()    {}
    81  func (*MsgRegisterAccountResponse) Descriptor() ([]byte, []int) {
    82  	return fileDescriptor_a726f12c2143215e, []int{1}
    83  }
    84  func (m *MsgRegisterAccountResponse) XXX_Unmarshal(b []byte) error {
    85  	return m.Unmarshal(b)
    86  }
    87  func (m *MsgRegisterAccountResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
    88  	if deterministic {
    89  		return xxx_messageInfo_MsgRegisterAccountResponse.Marshal(b, m, deterministic)
    90  	} else {
    91  		b = b[:cap(b)]
    92  		n, err := m.MarshalToSizedBuffer(b)
    93  		if err != nil {
    94  			return nil, err
    95  		}
    96  		return b[:n], nil
    97  	}
    98  }
    99  func (m *MsgRegisterAccountResponse) XXX_Merge(src proto.Message) {
   100  	xxx_messageInfo_MsgRegisterAccountResponse.Merge(m, src)
   101  }
   102  func (m *MsgRegisterAccountResponse) XXX_Size() int {
   103  	return m.Size()
   104  }
   105  func (m *MsgRegisterAccountResponse) XXX_DiscardUnknown() {
   106  	xxx_messageInfo_MsgRegisterAccountResponse.DiscardUnknown(m)
   107  }
   108  
   109  var xxx_messageInfo_MsgRegisterAccountResponse proto.InternalMessageInfo
   110  
   111  // MsgSubmitTx defines the payload for Msg/SubmitTx
   112  type MsgSubmitTx struct {
   113  	Owner        string     `protobuf:"bytes,1,opt,name=owner,proto3" json:"owner,omitempty"`
   114  	ConnectionId string     `protobuf:"bytes,2,opt,name=connection_id,json=connectionId,proto3" json:"connection_id,omitempty" yaml:"connection_id"`
   115  	Msg          *types.Any `protobuf:"bytes,3,opt,name=msg,proto3" json:"msg,omitempty"`
   116  }
   117  
   118  func (m *MsgSubmitTx) Reset()         { *m = MsgSubmitTx{} }
   119  func (m *MsgSubmitTx) String() string { return proto.CompactTextString(m) }
   120  func (*MsgSubmitTx) ProtoMessage()    {}
   121  func (*MsgSubmitTx) Descriptor() ([]byte, []int) {
   122  	return fileDescriptor_a726f12c2143215e, []int{2}
   123  }
   124  func (m *MsgSubmitTx) XXX_Unmarshal(b []byte) error {
   125  	return m.Unmarshal(b)
   126  }
   127  func (m *MsgSubmitTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   128  	if deterministic {
   129  		return xxx_messageInfo_MsgSubmitTx.Marshal(b, m, deterministic)
   130  	} else {
   131  		b = b[:cap(b)]
   132  		n, err := m.MarshalToSizedBuffer(b)
   133  		if err != nil {
   134  			return nil, err
   135  		}
   136  		return b[:n], nil
   137  	}
   138  }
   139  func (m *MsgSubmitTx) XXX_Merge(src proto.Message) {
   140  	xxx_messageInfo_MsgSubmitTx.Merge(m, src)
   141  }
   142  func (m *MsgSubmitTx) XXX_Size() int {
   143  	return m.Size()
   144  }
   145  func (m *MsgSubmitTx) XXX_DiscardUnknown() {
   146  	xxx_messageInfo_MsgSubmitTx.DiscardUnknown(m)
   147  }
   148  
   149  var xxx_messageInfo_MsgSubmitTx proto.InternalMessageInfo
   150  
   151  // MsgSubmitTxResponse defines the response for Msg/SubmitTx
   152  type MsgSubmitTxResponse struct {
   153  }
   154  
   155  func (m *MsgSubmitTxResponse) Reset()         { *m = MsgSubmitTxResponse{} }
   156  func (m *MsgSubmitTxResponse) String() string { return proto.CompactTextString(m) }
   157  func (*MsgSubmitTxResponse) ProtoMessage()    {}
   158  func (*MsgSubmitTxResponse) Descriptor() ([]byte, []int) {
   159  	return fileDescriptor_a726f12c2143215e, []int{3}
   160  }
   161  func (m *MsgSubmitTxResponse) XXX_Unmarshal(b []byte) error {
   162  	return m.Unmarshal(b)
   163  }
   164  func (m *MsgSubmitTxResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   165  	if deterministic {
   166  		return xxx_messageInfo_MsgSubmitTxResponse.Marshal(b, m, deterministic)
   167  	} else {
   168  		b = b[:cap(b)]
   169  		n, err := m.MarshalToSizedBuffer(b)
   170  		if err != nil {
   171  			return nil, err
   172  		}
   173  		return b[:n], nil
   174  	}
   175  }
   176  func (m *MsgSubmitTxResponse) XXX_Merge(src proto.Message) {
   177  	xxx_messageInfo_MsgSubmitTxResponse.Merge(m, src)
   178  }
   179  func (m *MsgSubmitTxResponse) XXX_Size() int {
   180  	return m.Size()
   181  }
   182  func (m *MsgSubmitTxResponse) XXX_DiscardUnknown() {
   183  	xxx_messageInfo_MsgSubmitTxResponse.DiscardUnknown(m)
   184  }
   185  
   186  var xxx_messageInfo_MsgSubmitTxResponse proto.InternalMessageInfo
   187  
   188  func init() {
   189  	proto.RegisterType((*MsgRegisterAccount)(nil), "gaia.icamauth.v1beta1.MsgRegisterAccount")
   190  	proto.RegisterType((*MsgRegisterAccountResponse)(nil), "gaia.icamauth.v1beta1.MsgRegisterAccountResponse")
   191  	proto.RegisterType((*MsgSubmitTx)(nil), "gaia.icamauth.v1beta1.MsgSubmitTx")
   192  	proto.RegisterType((*MsgSubmitTxResponse)(nil), "gaia.icamauth.v1beta1.MsgSubmitTxResponse")
   193  }
   194  
   195  func init() { proto.RegisterFile("gaia/icamauth/v1beta1/tx.proto", fileDescriptor_a726f12c2143215e) }
   196  
   197  var fileDescriptor_a726f12c2143215e = []byte{
   198  	// 387 bytes of a gzipped FileDescriptorProto
   199  	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4b, 0x4f, 0xcc, 0x4c,
   200  	0xd4, 0xcf, 0x4c, 0x4e, 0xcc, 0x4d, 0x2c, 0x2d, 0xc9, 0xd0, 0x2f, 0x33, 0x4c, 0x4a, 0x2d, 0x49,
   201  	0x34, 0xd4, 0x2f, 0xa9, 0xd0, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, 0x05, 0xc9, 0xeb, 0xc1,
   202  	0xe4, 0xf5, 0xa0, 0xf2, 0x52, 0x22, 0xe9, 0xf9, 0xe9, 0xf9, 0x60, 0x15, 0xfa, 0x20, 0x16, 0x44,
   203  	0xb1, 0x94, 0x64, 0x7a, 0x7e, 0x7e, 0x7a, 0x4e, 0xaa, 0x3e, 0x98, 0x97, 0x54, 0x9a, 0xa6, 0x9f,
   204  	0x98, 0x57, 0x09, 0x91, 0x52, 0xea, 0x65, 0xe4, 0x12, 0xf2, 0x2d, 0x4e, 0x0f, 0x4a, 0x4d, 0xcf,
   205  	0x2c, 0x2e, 0x49, 0x2d, 0x72, 0x4c, 0x4e, 0xce, 0x2f, 0xcd, 0x2b, 0x11, 0x12, 0xe1, 0x62, 0xcd,
   206  	0x2f, 0xcf, 0x4b, 0x2d, 0x92, 0x60, 0x54, 0x60, 0xd4, 0xe0, 0x0c, 0x82, 0x70, 0x84, 0x6c, 0xb9,
   207  	0x78, 0x93, 0xf3, 0xf3, 0xf2, 0x52, 0x93, 0x4b, 0x32, 0xf3, 0xf3, 0xe2, 0x33, 0x53, 0x24, 0x98,
   208  	0x40, 0xb2, 0x4e, 0x12, 0x9f, 0xee, 0xc9, 0x8b, 0x54, 0x26, 0xe6, 0xe6, 0x58, 0x29, 0xa1, 0x48,
   209  	0x2b, 0x05, 0xf1, 0x20, 0xf8, 0x9e, 0x29, 0x42, 0x12, 0x5c, 0xec, 0x65, 0xa9, 0x45, 0xc5, 0x99,
   210  	0xf9, 0x79, 0x12, 0xcc, 0x60, 0x63, 0x61, 0x5c, 0x2b, 0x8e, 0x8e, 0x05, 0xf2, 0x0c, 0x2f, 0x16,
   211  	0xc8, 0x33, 0x28, 0xc9, 0x70, 0x49, 0x61, 0x3a, 0x27, 0x28, 0xb5, 0xb8, 0x20, 0x3f, 0xaf, 0x38,
   212  	0x55, 0x69, 0x0a, 0x23, 0x17, 0xb7, 0x6f, 0x71, 0x7a, 0x70, 0x69, 0x52, 0x6e, 0x66, 0x49, 0x48,
   213  	0x05, 0x6d, 0x9c, 0xa9, 0xc6, 0xc5, 0x9c, 0x5b, 0x9c, 0x0e, 0x76, 0x22, 0xb7, 0x91, 0x88, 0x1e,
   214  	0x24, 0xec, 0xf4, 0x60, 0x61, 0xa7, 0xe7, 0x98, 0x57, 0x19, 0x04, 0x52, 0x80, 0xe4, 0x68, 0x51,
   215  	0x2e, 0x61, 0x24, 0x57, 0xc1, 0x5c, 0x6b, 0x74, 0x89, 0x91, 0x8b, 0xd9, 0xb7, 0x38, 0x5d, 0x28,
   216  	0x9f, 0x8b, 0x1f, 0x3d, 0x7c, 0x35, 0xf5, 0xb0, 0xc6, 0x9f, 0x1e, 0xa6, 0xdf, 0xa5, 0x0c, 0x89,
   217  	0x56, 0x0a, 0xb3, 0x58, 0x28, 0x8a, 0x8b, 0x03, 0x1e, 0x44, 0x4a, 0xb8, 0xb5, 0xc3, 0xd4, 0x48,
   218  	0x69, 0x11, 0x56, 0x03, 0x33, 0xdb, 0xc9, 0xf1, 0xc4, 0x23, 0x39, 0xc6, 0x0b, 0x8f, 0xe4, 0x18,
   219  	0x1f, 0x3c, 0x92, 0x63, 0x9c, 0xf0, 0x58, 0x8e, 0xe1, 0xc2, 0x63, 0x39, 0x86, 0x1b, 0x8f, 0xe5,
   220  	0x18, 0xa2, 0xd4, 0xd3, 0x33, 0x4b, 0x32, 0x4a, 0x93, 0xf4, 0x92, 0xf3, 0x73, 0xf5, 0x93, 0xf3,
   221  	0x8b, 0x73, 0xf3, 0x8b, 0xf5, 0xc1, 0x89, 0xb8, 0x02, 0x91, 0x8c, 0x4b, 0x2a, 0x0b, 0x52, 0x8b,
   222  	0x93, 0xd8, 0xc0, 0x61, 0x69, 0x0c, 0x08, 0x00, 0x00, 0xff, 0xff, 0x38, 0x4d, 0xe0, 0x45, 0xe4,
   223  	0x02, 0x00, 0x00,
   224  }
   225  
   226  // Reference imports to suppress errors if they are not otherwise used.
   227  var _ context.Context
   228  var _ grpc.ClientConn
   229  
   230  // This is a compile-time assertion to ensure that this generated file
   231  // is compatible with the grpc package it is being compiled against.
   232  const _ = grpc.SupportPackageIsVersion4
   233  
   234  // MsgClient is the client API for Msg service.
   235  //
   236  // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
   237  type MsgClient interface {
   238  	// Register defines a rpc handler for MsgRegisterAccount
   239  	RegisterAccount(ctx context.Context, in *MsgRegisterAccount, opts ...grpc.CallOption) (*MsgRegisterAccountResponse, error)
   240  	// SubmitTx defines a rpc handler for MsgSubmitTx
   241  	SubmitTx(ctx context.Context, in *MsgSubmitTx, opts ...grpc.CallOption) (*MsgSubmitTxResponse, error)
   242  }
   243  
   244  type msgClient struct {
   245  	cc grpc1.ClientConn
   246  }
   247  
   248  func NewMsgClient(cc grpc1.ClientConn) MsgClient {
   249  	return &msgClient{cc}
   250  }
   251  
   252  func (c *msgClient) RegisterAccount(ctx context.Context, in *MsgRegisterAccount, opts ...grpc.CallOption) (*MsgRegisterAccountResponse, error) {
   253  	out := new(MsgRegisterAccountResponse)
   254  	err := c.cc.Invoke(ctx, "/gaia.icamauth.v1beta1.Msg/RegisterAccount", in, out, opts...)
   255  	if err != nil {
   256  		return nil, err
   257  	}
   258  	return out, nil
   259  }
   260  
   261  func (c *msgClient) SubmitTx(ctx context.Context, in *MsgSubmitTx, opts ...grpc.CallOption) (*MsgSubmitTxResponse, error) {
   262  	out := new(MsgSubmitTxResponse)
   263  	err := c.cc.Invoke(ctx, "/gaia.icamauth.v1beta1.Msg/SubmitTx", in, out, opts...)
   264  	if err != nil {
   265  		return nil, err
   266  	}
   267  	return out, nil
   268  }
   269  
   270  // MsgServer is the server API for Msg service.
   271  type MsgServer interface {
   272  	// Register defines a rpc handler for MsgRegisterAccount
   273  	RegisterAccount(context.Context, *MsgRegisterAccount) (*MsgRegisterAccountResponse, error)
   274  	// SubmitTx defines a rpc handler for MsgSubmitTx
   275  	SubmitTx(context.Context, *MsgSubmitTx) (*MsgSubmitTxResponse, error)
   276  }
   277  
   278  // UnimplementedMsgServer can be embedded to have forward compatible implementations.
   279  type UnimplementedMsgServer struct {
   280  }
   281  
   282  func (*UnimplementedMsgServer) RegisterAccount(ctx context.Context, req *MsgRegisterAccount) (*MsgRegisterAccountResponse, error) {
   283  	return nil, status.Errorf(codes.Unimplemented, "method RegisterAccount not implemented")
   284  }
   285  func (*UnimplementedMsgServer) SubmitTx(ctx context.Context, req *MsgSubmitTx) (*MsgSubmitTxResponse, error) {
   286  	return nil, status.Errorf(codes.Unimplemented, "method SubmitTx not implemented")
   287  }
   288  
   289  func RegisterMsgServer(s grpc1.Server, srv MsgServer) {
   290  	s.RegisterService(&_Msg_serviceDesc, srv)
   291  }
   292  
   293  func _Msg_RegisterAccount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
   294  	in := new(MsgRegisterAccount)
   295  	if err := dec(in); err != nil {
   296  		return nil, err
   297  	}
   298  	if interceptor == nil {
   299  		return srv.(MsgServer).RegisterAccount(ctx, in)
   300  	}
   301  	info := &grpc.UnaryServerInfo{
   302  		Server:     srv,
   303  		FullMethod: "/gaia.icamauth.v1beta1.Msg/RegisterAccount",
   304  	}
   305  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
   306  		return srv.(MsgServer).RegisterAccount(ctx, req.(*MsgRegisterAccount))
   307  	}
   308  	return interceptor(ctx, in, info, handler)
   309  }
   310  
   311  func _Msg_SubmitTx_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
   312  	in := new(MsgSubmitTx)
   313  	if err := dec(in); err != nil {
   314  		return nil, err
   315  	}
   316  	if interceptor == nil {
   317  		return srv.(MsgServer).SubmitTx(ctx, in)
   318  	}
   319  	info := &grpc.UnaryServerInfo{
   320  		Server:     srv,
   321  		FullMethod: "/gaia.icamauth.v1beta1.Msg/SubmitTx",
   322  	}
   323  	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
   324  		return srv.(MsgServer).SubmitTx(ctx, req.(*MsgSubmitTx))
   325  	}
   326  	return interceptor(ctx, in, info, handler)
   327  }
   328  
   329  var _Msg_serviceDesc = grpc.ServiceDesc{
   330  	ServiceName: "gaia.icamauth.v1beta1.Msg",
   331  	HandlerType: (*MsgServer)(nil),
   332  	Methods: []grpc.MethodDesc{
   333  		{
   334  			MethodName: "RegisterAccount",
   335  			Handler:    _Msg_RegisterAccount_Handler,
   336  		},
   337  		{
   338  			MethodName: "SubmitTx",
   339  			Handler:    _Msg_SubmitTx_Handler,
   340  		},
   341  	},
   342  	Streams:  []grpc.StreamDesc{},
   343  	Metadata: "gaia/icamauth/v1beta1/tx.proto",
   344  }
   345  
   346  func (m *MsgRegisterAccount) Marshal() (dAtA []byte, err error) {
   347  	size := m.Size()
   348  	dAtA = make([]byte, size)
   349  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   350  	if err != nil {
   351  		return nil, err
   352  	}
   353  	return dAtA[:n], nil
   354  }
   355  
   356  func (m *MsgRegisterAccount) MarshalTo(dAtA []byte) (int, error) {
   357  	size := m.Size()
   358  	return m.MarshalToSizedBuffer(dAtA[:size])
   359  }
   360  
   361  func (m *MsgRegisterAccount) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   362  	i := len(dAtA)
   363  	_ = i
   364  	var l int
   365  	_ = l
   366  	if len(m.Version) > 0 {
   367  		i -= len(m.Version)
   368  		copy(dAtA[i:], m.Version)
   369  		i = encodeVarintTx(dAtA, i, uint64(len(m.Version)))
   370  		i--
   371  		dAtA[i] = 0x1a
   372  	}
   373  	if len(m.ConnectionId) > 0 {
   374  		i -= len(m.ConnectionId)
   375  		copy(dAtA[i:], m.ConnectionId)
   376  		i = encodeVarintTx(dAtA, i, uint64(len(m.ConnectionId)))
   377  		i--
   378  		dAtA[i] = 0x12
   379  	}
   380  	if len(m.Owner) > 0 {
   381  		i -= len(m.Owner)
   382  		copy(dAtA[i:], m.Owner)
   383  		i = encodeVarintTx(dAtA, i, uint64(len(m.Owner)))
   384  		i--
   385  		dAtA[i] = 0xa
   386  	}
   387  	return len(dAtA) - i, nil
   388  }
   389  
   390  func (m *MsgRegisterAccountResponse) Marshal() (dAtA []byte, err error) {
   391  	size := m.Size()
   392  	dAtA = make([]byte, size)
   393  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   394  	if err != nil {
   395  		return nil, err
   396  	}
   397  	return dAtA[:n], nil
   398  }
   399  
   400  func (m *MsgRegisterAccountResponse) MarshalTo(dAtA []byte) (int, error) {
   401  	size := m.Size()
   402  	return m.MarshalToSizedBuffer(dAtA[:size])
   403  }
   404  
   405  func (m *MsgRegisterAccountResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   406  	i := len(dAtA)
   407  	_ = i
   408  	var l int
   409  	_ = l
   410  	return len(dAtA) - i, nil
   411  }
   412  
   413  func (m *MsgSubmitTx) Marshal() (dAtA []byte, err error) {
   414  	size := m.Size()
   415  	dAtA = make([]byte, size)
   416  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   417  	if err != nil {
   418  		return nil, err
   419  	}
   420  	return dAtA[:n], nil
   421  }
   422  
   423  func (m *MsgSubmitTx) MarshalTo(dAtA []byte) (int, error) {
   424  	size := m.Size()
   425  	return m.MarshalToSizedBuffer(dAtA[:size])
   426  }
   427  
   428  func (m *MsgSubmitTx) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   429  	i := len(dAtA)
   430  	_ = i
   431  	var l int
   432  	_ = l
   433  	if m.Msg != nil {
   434  		{
   435  			size, err := m.Msg.MarshalToSizedBuffer(dAtA[:i])
   436  			if err != nil {
   437  				return 0, err
   438  			}
   439  			i -= size
   440  			i = encodeVarintTx(dAtA, i, uint64(size))
   441  		}
   442  		i--
   443  		dAtA[i] = 0x1a
   444  	}
   445  	if len(m.ConnectionId) > 0 {
   446  		i -= len(m.ConnectionId)
   447  		copy(dAtA[i:], m.ConnectionId)
   448  		i = encodeVarintTx(dAtA, i, uint64(len(m.ConnectionId)))
   449  		i--
   450  		dAtA[i] = 0x12
   451  	}
   452  	if len(m.Owner) > 0 {
   453  		i -= len(m.Owner)
   454  		copy(dAtA[i:], m.Owner)
   455  		i = encodeVarintTx(dAtA, i, uint64(len(m.Owner)))
   456  		i--
   457  		dAtA[i] = 0xa
   458  	}
   459  	return len(dAtA) - i, nil
   460  }
   461  
   462  func (m *MsgSubmitTxResponse) Marshal() (dAtA []byte, err error) {
   463  	size := m.Size()
   464  	dAtA = make([]byte, size)
   465  	n, err := m.MarshalToSizedBuffer(dAtA[:size])
   466  	if err != nil {
   467  		return nil, err
   468  	}
   469  	return dAtA[:n], nil
   470  }
   471  
   472  func (m *MsgSubmitTxResponse) MarshalTo(dAtA []byte) (int, error) {
   473  	size := m.Size()
   474  	return m.MarshalToSizedBuffer(dAtA[:size])
   475  }
   476  
   477  func (m *MsgSubmitTxResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   478  	i := len(dAtA)
   479  	_ = i
   480  	var l int
   481  	_ = l
   482  	return len(dAtA) - i, nil
   483  }
   484  
   485  func encodeVarintTx(dAtA []byte, offset int, v uint64) int {
   486  	offset -= sovTx(v)
   487  	base := offset
   488  	for v >= 1<<7 {
   489  		dAtA[offset] = uint8(v&0x7f | 0x80)
   490  		v >>= 7
   491  		offset++
   492  	}
   493  	dAtA[offset] = uint8(v)
   494  	return base
   495  }
   496  func (m *MsgRegisterAccount) Size() (n int) {
   497  	if m == nil {
   498  		return 0
   499  	}
   500  	var l int
   501  	_ = l
   502  	l = len(m.Owner)
   503  	if l > 0 {
   504  		n += 1 + l + sovTx(uint64(l))
   505  	}
   506  	l = len(m.ConnectionId)
   507  	if l > 0 {
   508  		n += 1 + l + sovTx(uint64(l))
   509  	}
   510  	l = len(m.Version)
   511  	if l > 0 {
   512  		n += 1 + l + sovTx(uint64(l))
   513  	}
   514  	return n
   515  }
   516  
   517  func (m *MsgRegisterAccountResponse) Size() (n int) {
   518  	if m == nil {
   519  		return 0
   520  	}
   521  	var l int
   522  	_ = l
   523  	return n
   524  }
   525  
   526  func (m *MsgSubmitTx) Size() (n int) {
   527  	if m == nil {
   528  		return 0
   529  	}
   530  	var l int
   531  	_ = l
   532  	l = len(m.Owner)
   533  	if l > 0 {
   534  		n += 1 + l + sovTx(uint64(l))
   535  	}
   536  	l = len(m.ConnectionId)
   537  	if l > 0 {
   538  		n += 1 + l + sovTx(uint64(l))
   539  	}
   540  	if m.Msg != nil {
   541  		l = m.Msg.Size()
   542  		n += 1 + l + sovTx(uint64(l))
   543  	}
   544  	return n
   545  }
   546  
   547  func (m *MsgSubmitTxResponse) Size() (n int) {
   548  	if m == nil {
   549  		return 0
   550  	}
   551  	var l int
   552  	_ = l
   553  	return n
   554  }
   555  
   556  func sovTx(x uint64) (n int) {
   557  	return (math_bits.Len64(x|1) + 6) / 7
   558  }
   559  func sozTx(x uint64) (n int) {
   560  	return sovTx(uint64((x << 1) ^ uint64((int64(x) >> 63))))
   561  }
   562  func (m *MsgRegisterAccount) Unmarshal(dAtA []byte) error {
   563  	l := len(dAtA)
   564  	iNdEx := 0
   565  	for iNdEx < l {
   566  		preIndex := iNdEx
   567  		var wire uint64
   568  		for shift := uint(0); ; shift += 7 {
   569  			if shift >= 64 {
   570  				return ErrIntOverflowTx
   571  			}
   572  			if iNdEx >= l {
   573  				return io.ErrUnexpectedEOF
   574  			}
   575  			b := dAtA[iNdEx]
   576  			iNdEx++
   577  			wire |= uint64(b&0x7F) << shift
   578  			if b < 0x80 {
   579  				break
   580  			}
   581  		}
   582  		fieldNum := int32(wire >> 3)
   583  		wireType := int(wire & 0x7)
   584  		if wireType == 4 {
   585  			return fmt.Errorf("proto: MsgRegisterAccount: wiretype end group for non-group")
   586  		}
   587  		if fieldNum <= 0 {
   588  			return fmt.Errorf("proto: MsgRegisterAccount: illegal tag %d (wire type %d)", fieldNum, wire)
   589  		}
   590  		switch fieldNum {
   591  		case 1:
   592  			if wireType != 2 {
   593  				return fmt.Errorf("proto: wrong wireType = %d for field Owner", wireType)
   594  			}
   595  			var stringLen uint64
   596  			for shift := uint(0); ; shift += 7 {
   597  				if shift >= 64 {
   598  					return ErrIntOverflowTx
   599  				}
   600  				if iNdEx >= l {
   601  					return io.ErrUnexpectedEOF
   602  				}
   603  				b := dAtA[iNdEx]
   604  				iNdEx++
   605  				stringLen |= uint64(b&0x7F) << shift
   606  				if b < 0x80 {
   607  					break
   608  				}
   609  			}
   610  			intStringLen := int(stringLen)
   611  			if intStringLen < 0 {
   612  				return ErrInvalidLengthTx
   613  			}
   614  			postIndex := iNdEx + intStringLen
   615  			if postIndex < 0 {
   616  				return ErrInvalidLengthTx
   617  			}
   618  			if postIndex > l {
   619  				return io.ErrUnexpectedEOF
   620  			}
   621  			m.Owner = string(dAtA[iNdEx:postIndex])
   622  			iNdEx = postIndex
   623  		case 2:
   624  			if wireType != 2 {
   625  				return fmt.Errorf("proto: wrong wireType = %d for field ConnectionId", wireType)
   626  			}
   627  			var stringLen uint64
   628  			for shift := uint(0); ; shift += 7 {
   629  				if shift >= 64 {
   630  					return ErrIntOverflowTx
   631  				}
   632  				if iNdEx >= l {
   633  					return io.ErrUnexpectedEOF
   634  				}
   635  				b := dAtA[iNdEx]
   636  				iNdEx++
   637  				stringLen |= uint64(b&0x7F) << shift
   638  				if b < 0x80 {
   639  					break
   640  				}
   641  			}
   642  			intStringLen := int(stringLen)
   643  			if intStringLen < 0 {
   644  				return ErrInvalidLengthTx
   645  			}
   646  			postIndex := iNdEx + intStringLen
   647  			if postIndex < 0 {
   648  				return ErrInvalidLengthTx
   649  			}
   650  			if postIndex > l {
   651  				return io.ErrUnexpectedEOF
   652  			}
   653  			m.ConnectionId = string(dAtA[iNdEx:postIndex])
   654  			iNdEx = postIndex
   655  		case 3:
   656  			if wireType != 2 {
   657  				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
   658  			}
   659  			var stringLen uint64
   660  			for shift := uint(0); ; shift += 7 {
   661  				if shift >= 64 {
   662  					return ErrIntOverflowTx
   663  				}
   664  				if iNdEx >= l {
   665  					return io.ErrUnexpectedEOF
   666  				}
   667  				b := dAtA[iNdEx]
   668  				iNdEx++
   669  				stringLen |= uint64(b&0x7F) << shift
   670  				if b < 0x80 {
   671  					break
   672  				}
   673  			}
   674  			intStringLen := int(stringLen)
   675  			if intStringLen < 0 {
   676  				return ErrInvalidLengthTx
   677  			}
   678  			postIndex := iNdEx + intStringLen
   679  			if postIndex < 0 {
   680  				return ErrInvalidLengthTx
   681  			}
   682  			if postIndex > l {
   683  				return io.ErrUnexpectedEOF
   684  			}
   685  			m.Version = string(dAtA[iNdEx:postIndex])
   686  			iNdEx = postIndex
   687  		default:
   688  			iNdEx = preIndex
   689  			skippy, err := skipTx(dAtA[iNdEx:])
   690  			if err != nil {
   691  				return err
   692  			}
   693  			if (skippy < 0) || (iNdEx+skippy) < 0 {
   694  				return ErrInvalidLengthTx
   695  			}
   696  			if (iNdEx + skippy) > l {
   697  				return io.ErrUnexpectedEOF
   698  			}
   699  			iNdEx += skippy
   700  		}
   701  	}
   702  
   703  	if iNdEx > l {
   704  		return io.ErrUnexpectedEOF
   705  	}
   706  	return nil
   707  }
   708  func (m *MsgRegisterAccountResponse) Unmarshal(dAtA []byte) error {
   709  	l := len(dAtA)
   710  	iNdEx := 0
   711  	for iNdEx < l {
   712  		preIndex := iNdEx
   713  		var wire uint64
   714  		for shift := uint(0); ; shift += 7 {
   715  			if shift >= 64 {
   716  				return ErrIntOverflowTx
   717  			}
   718  			if iNdEx >= l {
   719  				return io.ErrUnexpectedEOF
   720  			}
   721  			b := dAtA[iNdEx]
   722  			iNdEx++
   723  			wire |= uint64(b&0x7F) << shift
   724  			if b < 0x80 {
   725  				break
   726  			}
   727  		}
   728  		fieldNum := int32(wire >> 3)
   729  		wireType := int(wire & 0x7)
   730  		if wireType == 4 {
   731  			return fmt.Errorf("proto: MsgRegisterAccountResponse: wiretype end group for non-group")
   732  		}
   733  		if fieldNum <= 0 {
   734  			return fmt.Errorf("proto: MsgRegisterAccountResponse: illegal tag %d (wire type %d)", fieldNum, wire)
   735  		}
   736  		switch fieldNum {
   737  		default:
   738  			iNdEx = preIndex
   739  			skippy, err := skipTx(dAtA[iNdEx:])
   740  			if err != nil {
   741  				return err
   742  			}
   743  			if (skippy < 0) || (iNdEx+skippy) < 0 {
   744  				return ErrInvalidLengthTx
   745  			}
   746  			if (iNdEx + skippy) > l {
   747  				return io.ErrUnexpectedEOF
   748  			}
   749  			iNdEx += skippy
   750  		}
   751  	}
   752  
   753  	if iNdEx > l {
   754  		return io.ErrUnexpectedEOF
   755  	}
   756  	return nil
   757  }
   758  func (m *MsgSubmitTx) Unmarshal(dAtA []byte) error {
   759  	l := len(dAtA)
   760  	iNdEx := 0
   761  	for iNdEx < l {
   762  		preIndex := iNdEx
   763  		var wire uint64
   764  		for shift := uint(0); ; shift += 7 {
   765  			if shift >= 64 {
   766  				return ErrIntOverflowTx
   767  			}
   768  			if iNdEx >= l {
   769  				return io.ErrUnexpectedEOF
   770  			}
   771  			b := dAtA[iNdEx]
   772  			iNdEx++
   773  			wire |= uint64(b&0x7F) << shift
   774  			if b < 0x80 {
   775  				break
   776  			}
   777  		}
   778  		fieldNum := int32(wire >> 3)
   779  		wireType := int(wire & 0x7)
   780  		if wireType == 4 {
   781  			return fmt.Errorf("proto: MsgSubmitTx: wiretype end group for non-group")
   782  		}
   783  		if fieldNum <= 0 {
   784  			return fmt.Errorf("proto: MsgSubmitTx: illegal tag %d (wire type %d)", fieldNum, wire)
   785  		}
   786  		switch fieldNum {
   787  		case 1:
   788  			if wireType != 2 {
   789  				return fmt.Errorf("proto: wrong wireType = %d for field Owner", wireType)
   790  			}
   791  			var stringLen uint64
   792  			for shift := uint(0); ; shift += 7 {
   793  				if shift >= 64 {
   794  					return ErrIntOverflowTx
   795  				}
   796  				if iNdEx >= l {
   797  					return io.ErrUnexpectedEOF
   798  				}
   799  				b := dAtA[iNdEx]
   800  				iNdEx++
   801  				stringLen |= uint64(b&0x7F) << shift
   802  				if b < 0x80 {
   803  					break
   804  				}
   805  			}
   806  			intStringLen := int(stringLen)
   807  			if intStringLen < 0 {
   808  				return ErrInvalidLengthTx
   809  			}
   810  			postIndex := iNdEx + intStringLen
   811  			if postIndex < 0 {
   812  				return ErrInvalidLengthTx
   813  			}
   814  			if postIndex > l {
   815  				return io.ErrUnexpectedEOF
   816  			}
   817  			m.Owner = string(dAtA[iNdEx:postIndex])
   818  			iNdEx = postIndex
   819  		case 2:
   820  			if wireType != 2 {
   821  				return fmt.Errorf("proto: wrong wireType = %d for field ConnectionId", wireType)
   822  			}
   823  			var stringLen uint64
   824  			for shift := uint(0); ; shift += 7 {
   825  				if shift >= 64 {
   826  					return ErrIntOverflowTx
   827  				}
   828  				if iNdEx >= l {
   829  					return io.ErrUnexpectedEOF
   830  				}
   831  				b := dAtA[iNdEx]
   832  				iNdEx++
   833  				stringLen |= uint64(b&0x7F) << shift
   834  				if b < 0x80 {
   835  					break
   836  				}
   837  			}
   838  			intStringLen := int(stringLen)
   839  			if intStringLen < 0 {
   840  				return ErrInvalidLengthTx
   841  			}
   842  			postIndex := iNdEx + intStringLen
   843  			if postIndex < 0 {
   844  				return ErrInvalidLengthTx
   845  			}
   846  			if postIndex > l {
   847  				return io.ErrUnexpectedEOF
   848  			}
   849  			m.ConnectionId = string(dAtA[iNdEx:postIndex])
   850  			iNdEx = postIndex
   851  		case 3:
   852  			if wireType != 2 {
   853  				return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType)
   854  			}
   855  			var msglen int
   856  			for shift := uint(0); ; shift += 7 {
   857  				if shift >= 64 {
   858  					return ErrIntOverflowTx
   859  				}
   860  				if iNdEx >= l {
   861  					return io.ErrUnexpectedEOF
   862  				}
   863  				b := dAtA[iNdEx]
   864  				iNdEx++
   865  				msglen |= int(b&0x7F) << shift
   866  				if b < 0x80 {
   867  					break
   868  				}
   869  			}
   870  			if msglen < 0 {
   871  				return ErrInvalidLengthTx
   872  			}
   873  			postIndex := iNdEx + msglen
   874  			if postIndex < 0 {
   875  				return ErrInvalidLengthTx
   876  			}
   877  			if postIndex > l {
   878  				return io.ErrUnexpectedEOF
   879  			}
   880  			if m.Msg == nil {
   881  				m.Msg = &types.Any{}
   882  			}
   883  			if err := m.Msg.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
   884  				return err
   885  			}
   886  			iNdEx = postIndex
   887  		default:
   888  			iNdEx = preIndex
   889  			skippy, err := skipTx(dAtA[iNdEx:])
   890  			if err != nil {
   891  				return err
   892  			}
   893  			if (skippy < 0) || (iNdEx+skippy) < 0 {
   894  				return ErrInvalidLengthTx
   895  			}
   896  			if (iNdEx + skippy) > l {
   897  				return io.ErrUnexpectedEOF
   898  			}
   899  			iNdEx += skippy
   900  		}
   901  	}
   902  
   903  	if iNdEx > l {
   904  		return io.ErrUnexpectedEOF
   905  	}
   906  	return nil
   907  }
   908  func (m *MsgSubmitTxResponse) Unmarshal(dAtA []byte) error {
   909  	l := len(dAtA)
   910  	iNdEx := 0
   911  	for iNdEx < l {
   912  		preIndex := iNdEx
   913  		var wire uint64
   914  		for shift := uint(0); ; shift += 7 {
   915  			if shift >= 64 {
   916  				return ErrIntOverflowTx
   917  			}
   918  			if iNdEx >= l {
   919  				return io.ErrUnexpectedEOF
   920  			}
   921  			b := dAtA[iNdEx]
   922  			iNdEx++
   923  			wire |= uint64(b&0x7F) << shift
   924  			if b < 0x80 {
   925  				break
   926  			}
   927  		}
   928  		fieldNum := int32(wire >> 3)
   929  		wireType := int(wire & 0x7)
   930  		if wireType == 4 {
   931  			return fmt.Errorf("proto: MsgSubmitTxResponse: wiretype end group for non-group")
   932  		}
   933  		if fieldNum <= 0 {
   934  			return fmt.Errorf("proto: MsgSubmitTxResponse: illegal tag %d (wire type %d)", fieldNum, wire)
   935  		}
   936  		switch fieldNum {
   937  		default:
   938  			iNdEx = preIndex
   939  			skippy, err := skipTx(dAtA[iNdEx:])
   940  			if err != nil {
   941  				return err
   942  			}
   943  			if (skippy < 0) || (iNdEx+skippy) < 0 {
   944  				return ErrInvalidLengthTx
   945  			}
   946  			if (iNdEx + skippy) > l {
   947  				return io.ErrUnexpectedEOF
   948  			}
   949  			iNdEx += skippy
   950  		}
   951  	}
   952  
   953  	if iNdEx > l {
   954  		return io.ErrUnexpectedEOF
   955  	}
   956  	return nil
   957  }
   958  func skipTx(dAtA []byte) (n int, err error) {
   959  	l := len(dAtA)
   960  	iNdEx := 0
   961  	depth := 0
   962  	for iNdEx < l {
   963  		var wire uint64
   964  		for shift := uint(0); ; shift += 7 {
   965  			if shift >= 64 {
   966  				return 0, ErrIntOverflowTx
   967  			}
   968  			if iNdEx >= l {
   969  				return 0, io.ErrUnexpectedEOF
   970  			}
   971  			b := dAtA[iNdEx]
   972  			iNdEx++
   973  			wire |= (uint64(b) & 0x7F) << shift
   974  			if b < 0x80 {
   975  				break
   976  			}
   977  		}
   978  		wireType := int(wire & 0x7)
   979  		switch wireType {
   980  		case 0:
   981  			for shift := uint(0); ; shift += 7 {
   982  				if shift >= 64 {
   983  					return 0, ErrIntOverflowTx
   984  				}
   985  				if iNdEx >= l {
   986  					return 0, io.ErrUnexpectedEOF
   987  				}
   988  				iNdEx++
   989  				if dAtA[iNdEx-1] < 0x80 {
   990  					break
   991  				}
   992  			}
   993  		case 1:
   994  			iNdEx += 8
   995  		case 2:
   996  			var length int
   997  			for shift := uint(0); ; shift += 7 {
   998  				if shift >= 64 {
   999  					return 0, ErrIntOverflowTx
  1000  				}
  1001  				if iNdEx >= l {
  1002  					return 0, io.ErrUnexpectedEOF
  1003  				}
  1004  				b := dAtA[iNdEx]
  1005  				iNdEx++
  1006  				length |= (int(b) & 0x7F) << shift
  1007  				if b < 0x80 {
  1008  					break
  1009  				}
  1010  			}
  1011  			if length < 0 {
  1012  				return 0, ErrInvalidLengthTx
  1013  			}
  1014  			iNdEx += length
  1015  		case 3:
  1016  			depth++
  1017  		case 4:
  1018  			if depth == 0 {
  1019  				return 0, ErrUnexpectedEndOfGroupTx
  1020  			}
  1021  			depth--
  1022  		case 5:
  1023  			iNdEx += 4
  1024  		default:
  1025  			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
  1026  		}
  1027  		if iNdEx < 0 {
  1028  			return 0, ErrInvalidLengthTx
  1029  		}
  1030  		if depth == 0 {
  1031  			return iNdEx, nil
  1032  		}
  1033  	}
  1034  	return 0, io.ErrUnexpectedEOF
  1035  }
  1036  
  1037  var (
  1038  	ErrInvalidLengthTx        = fmt.Errorf("proto: negative length found during unmarshaling")
  1039  	ErrIntOverflowTx          = fmt.Errorf("proto: integer overflow")
  1040  	ErrUnexpectedEndOfGroupTx = fmt.Errorf("proto: unexpected end of group")
  1041  )