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 )