github.com/Finschia/finschia-sdk@v0.48.1/x/staking/types/query.pb.gw.go (about) 1 // Code generated by protoc-gen-grpc-gateway. DO NOT EDIT. 2 // source: cosmos/staking/v1beta1/query.proto 3 4 /* 5 Package types is a reverse proxy. 6 7 It translates gRPC into RESTful JSON APIs. 8 */ 9 package types 10 11 import ( 12 "context" 13 "io" 14 "net/http" 15 16 "github.com/golang/protobuf/descriptor" 17 "github.com/golang/protobuf/proto" 18 "github.com/grpc-ecosystem/grpc-gateway/runtime" 19 "github.com/grpc-ecosystem/grpc-gateway/utilities" 20 "google.golang.org/grpc" 21 "google.golang.org/grpc/codes" 22 "google.golang.org/grpc/grpclog" 23 "google.golang.org/grpc/status" 24 ) 25 26 // Suppress "imported and not used" errors 27 var _ codes.Code 28 var _ io.Reader 29 var _ status.Status 30 var _ = runtime.String 31 var _ = utilities.NewDoubleArray 32 var _ = descriptor.ForMessage 33 34 var ( 35 filter_Query_Validators_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} 36 ) 37 38 func request_Query_Validators_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 39 var protoReq QueryValidatorsRequest 40 var metadata runtime.ServerMetadata 41 42 if err := req.ParseForm(); err != nil { 43 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 44 } 45 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_Validators_0); err != nil { 46 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 47 } 48 49 msg, err := client.Validators(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 50 return msg, metadata, err 51 52 } 53 54 func local_request_Query_Validators_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 55 var protoReq QueryValidatorsRequest 56 var metadata runtime.ServerMetadata 57 58 if err := req.ParseForm(); err != nil { 59 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 60 } 61 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_Validators_0); err != nil { 62 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 63 } 64 65 msg, err := server.Validators(ctx, &protoReq) 66 return msg, metadata, err 67 68 } 69 70 func request_Query_Validator_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 71 var protoReq QueryValidatorRequest 72 var metadata runtime.ServerMetadata 73 74 var ( 75 val string 76 ok bool 77 err error 78 _ = err 79 ) 80 81 val, ok = pathParams["validator_addr"] 82 if !ok { 83 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "validator_addr") 84 } 85 86 protoReq.ValidatorAddr, err = runtime.String(val) 87 88 if err != nil { 89 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "validator_addr", err) 90 } 91 92 msg, err := client.Validator(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 93 return msg, metadata, err 94 95 } 96 97 func local_request_Query_Validator_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 98 var protoReq QueryValidatorRequest 99 var metadata runtime.ServerMetadata 100 101 var ( 102 val string 103 ok bool 104 err error 105 _ = err 106 ) 107 108 val, ok = pathParams["validator_addr"] 109 if !ok { 110 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "validator_addr") 111 } 112 113 protoReq.ValidatorAddr, err = runtime.String(val) 114 115 if err != nil { 116 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "validator_addr", err) 117 } 118 119 msg, err := server.Validator(ctx, &protoReq) 120 return msg, metadata, err 121 122 } 123 124 var ( 125 filter_Query_ValidatorDelegations_0 = &utilities.DoubleArray{Encoding: map[string]int{"validator_addr": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}} 126 ) 127 128 func request_Query_ValidatorDelegations_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 129 var protoReq QueryValidatorDelegationsRequest 130 var metadata runtime.ServerMetadata 131 132 var ( 133 val string 134 ok bool 135 err error 136 _ = err 137 ) 138 139 val, ok = pathParams["validator_addr"] 140 if !ok { 141 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "validator_addr") 142 } 143 144 protoReq.ValidatorAddr, err = runtime.String(val) 145 146 if err != nil { 147 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "validator_addr", err) 148 } 149 150 if err := req.ParseForm(); err != nil { 151 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 152 } 153 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_ValidatorDelegations_0); err != nil { 154 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 155 } 156 157 msg, err := client.ValidatorDelegations(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 158 return msg, metadata, err 159 160 } 161 162 func local_request_Query_ValidatorDelegations_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 163 var protoReq QueryValidatorDelegationsRequest 164 var metadata runtime.ServerMetadata 165 166 var ( 167 val string 168 ok bool 169 err error 170 _ = err 171 ) 172 173 val, ok = pathParams["validator_addr"] 174 if !ok { 175 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "validator_addr") 176 } 177 178 protoReq.ValidatorAddr, err = runtime.String(val) 179 180 if err != nil { 181 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "validator_addr", err) 182 } 183 184 if err := req.ParseForm(); err != nil { 185 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 186 } 187 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_ValidatorDelegations_0); err != nil { 188 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 189 } 190 191 msg, err := server.ValidatorDelegations(ctx, &protoReq) 192 return msg, metadata, err 193 194 } 195 196 var ( 197 filter_Query_ValidatorUnbondingDelegations_0 = &utilities.DoubleArray{Encoding: map[string]int{"validator_addr": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}} 198 ) 199 200 func request_Query_ValidatorUnbondingDelegations_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 201 var protoReq QueryValidatorUnbondingDelegationsRequest 202 var metadata runtime.ServerMetadata 203 204 var ( 205 val string 206 ok bool 207 err error 208 _ = err 209 ) 210 211 val, ok = pathParams["validator_addr"] 212 if !ok { 213 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "validator_addr") 214 } 215 216 protoReq.ValidatorAddr, err = runtime.String(val) 217 218 if err != nil { 219 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "validator_addr", err) 220 } 221 222 if err := req.ParseForm(); err != nil { 223 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 224 } 225 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_ValidatorUnbondingDelegations_0); err != nil { 226 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 227 } 228 229 msg, err := client.ValidatorUnbondingDelegations(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 230 return msg, metadata, err 231 232 } 233 234 func local_request_Query_ValidatorUnbondingDelegations_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 235 var protoReq QueryValidatorUnbondingDelegationsRequest 236 var metadata runtime.ServerMetadata 237 238 var ( 239 val string 240 ok bool 241 err error 242 _ = err 243 ) 244 245 val, ok = pathParams["validator_addr"] 246 if !ok { 247 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "validator_addr") 248 } 249 250 protoReq.ValidatorAddr, err = runtime.String(val) 251 252 if err != nil { 253 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "validator_addr", err) 254 } 255 256 if err := req.ParseForm(); err != nil { 257 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 258 } 259 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_ValidatorUnbondingDelegations_0); err != nil { 260 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 261 } 262 263 msg, err := server.ValidatorUnbondingDelegations(ctx, &protoReq) 264 return msg, metadata, err 265 266 } 267 268 func request_Query_Delegation_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 269 var protoReq QueryDelegationRequest 270 var metadata runtime.ServerMetadata 271 272 var ( 273 val string 274 ok bool 275 err error 276 _ = err 277 ) 278 279 val, ok = pathParams["validator_addr"] 280 if !ok { 281 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "validator_addr") 282 } 283 284 protoReq.ValidatorAddr, err = runtime.String(val) 285 286 if err != nil { 287 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "validator_addr", err) 288 } 289 290 val, ok = pathParams["delegator_addr"] 291 if !ok { 292 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "delegator_addr") 293 } 294 295 protoReq.DelegatorAddr, err = runtime.String(val) 296 297 if err != nil { 298 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "delegator_addr", err) 299 } 300 301 msg, err := client.Delegation(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 302 return msg, metadata, err 303 304 } 305 306 func local_request_Query_Delegation_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 307 var protoReq QueryDelegationRequest 308 var metadata runtime.ServerMetadata 309 310 var ( 311 val string 312 ok bool 313 err error 314 _ = err 315 ) 316 317 val, ok = pathParams["validator_addr"] 318 if !ok { 319 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "validator_addr") 320 } 321 322 protoReq.ValidatorAddr, err = runtime.String(val) 323 324 if err != nil { 325 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "validator_addr", err) 326 } 327 328 val, ok = pathParams["delegator_addr"] 329 if !ok { 330 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "delegator_addr") 331 } 332 333 protoReq.DelegatorAddr, err = runtime.String(val) 334 335 if err != nil { 336 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "delegator_addr", err) 337 } 338 339 msg, err := server.Delegation(ctx, &protoReq) 340 return msg, metadata, err 341 342 } 343 344 func request_Query_UnbondingDelegation_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 345 var protoReq QueryUnbondingDelegationRequest 346 var metadata runtime.ServerMetadata 347 348 var ( 349 val string 350 ok bool 351 err error 352 _ = err 353 ) 354 355 val, ok = pathParams["validator_addr"] 356 if !ok { 357 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "validator_addr") 358 } 359 360 protoReq.ValidatorAddr, err = runtime.String(val) 361 362 if err != nil { 363 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "validator_addr", err) 364 } 365 366 val, ok = pathParams["delegator_addr"] 367 if !ok { 368 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "delegator_addr") 369 } 370 371 protoReq.DelegatorAddr, err = runtime.String(val) 372 373 if err != nil { 374 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "delegator_addr", err) 375 } 376 377 msg, err := client.UnbondingDelegation(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 378 return msg, metadata, err 379 380 } 381 382 func local_request_Query_UnbondingDelegation_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 383 var protoReq QueryUnbondingDelegationRequest 384 var metadata runtime.ServerMetadata 385 386 var ( 387 val string 388 ok bool 389 err error 390 _ = err 391 ) 392 393 val, ok = pathParams["validator_addr"] 394 if !ok { 395 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "validator_addr") 396 } 397 398 protoReq.ValidatorAddr, err = runtime.String(val) 399 400 if err != nil { 401 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "validator_addr", err) 402 } 403 404 val, ok = pathParams["delegator_addr"] 405 if !ok { 406 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "delegator_addr") 407 } 408 409 protoReq.DelegatorAddr, err = runtime.String(val) 410 411 if err != nil { 412 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "delegator_addr", err) 413 } 414 415 msg, err := server.UnbondingDelegation(ctx, &protoReq) 416 return msg, metadata, err 417 418 } 419 420 var ( 421 filter_Query_DelegatorDelegations_0 = &utilities.DoubleArray{Encoding: map[string]int{"delegator_addr": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}} 422 ) 423 424 func request_Query_DelegatorDelegations_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 425 var protoReq QueryDelegatorDelegationsRequest 426 var metadata runtime.ServerMetadata 427 428 var ( 429 val string 430 ok bool 431 err error 432 _ = err 433 ) 434 435 val, ok = pathParams["delegator_addr"] 436 if !ok { 437 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "delegator_addr") 438 } 439 440 protoReq.DelegatorAddr, err = runtime.String(val) 441 442 if err != nil { 443 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "delegator_addr", err) 444 } 445 446 if err := req.ParseForm(); err != nil { 447 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 448 } 449 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_DelegatorDelegations_0); err != nil { 450 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 451 } 452 453 msg, err := client.DelegatorDelegations(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 454 return msg, metadata, err 455 456 } 457 458 func local_request_Query_DelegatorDelegations_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 459 var protoReq QueryDelegatorDelegationsRequest 460 var metadata runtime.ServerMetadata 461 462 var ( 463 val string 464 ok bool 465 err error 466 _ = err 467 ) 468 469 val, ok = pathParams["delegator_addr"] 470 if !ok { 471 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "delegator_addr") 472 } 473 474 protoReq.DelegatorAddr, err = runtime.String(val) 475 476 if err != nil { 477 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "delegator_addr", err) 478 } 479 480 if err := req.ParseForm(); err != nil { 481 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 482 } 483 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_DelegatorDelegations_0); err != nil { 484 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 485 } 486 487 msg, err := server.DelegatorDelegations(ctx, &protoReq) 488 return msg, metadata, err 489 490 } 491 492 var ( 493 filter_Query_DelegatorUnbondingDelegations_0 = &utilities.DoubleArray{Encoding: map[string]int{"delegator_addr": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}} 494 ) 495 496 func request_Query_DelegatorUnbondingDelegations_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 497 var protoReq QueryDelegatorUnbondingDelegationsRequest 498 var metadata runtime.ServerMetadata 499 500 var ( 501 val string 502 ok bool 503 err error 504 _ = err 505 ) 506 507 val, ok = pathParams["delegator_addr"] 508 if !ok { 509 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "delegator_addr") 510 } 511 512 protoReq.DelegatorAddr, err = runtime.String(val) 513 514 if err != nil { 515 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "delegator_addr", err) 516 } 517 518 if err := req.ParseForm(); err != nil { 519 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 520 } 521 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_DelegatorUnbondingDelegations_0); err != nil { 522 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 523 } 524 525 msg, err := client.DelegatorUnbondingDelegations(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 526 return msg, metadata, err 527 528 } 529 530 func local_request_Query_DelegatorUnbondingDelegations_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 531 var protoReq QueryDelegatorUnbondingDelegationsRequest 532 var metadata runtime.ServerMetadata 533 534 var ( 535 val string 536 ok bool 537 err error 538 _ = err 539 ) 540 541 val, ok = pathParams["delegator_addr"] 542 if !ok { 543 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "delegator_addr") 544 } 545 546 protoReq.DelegatorAddr, err = runtime.String(val) 547 548 if err != nil { 549 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "delegator_addr", err) 550 } 551 552 if err := req.ParseForm(); err != nil { 553 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 554 } 555 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_DelegatorUnbondingDelegations_0); err != nil { 556 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 557 } 558 559 msg, err := server.DelegatorUnbondingDelegations(ctx, &protoReq) 560 return msg, metadata, err 561 562 } 563 564 var ( 565 filter_Query_Redelegations_0 = &utilities.DoubleArray{Encoding: map[string]int{"delegator_addr": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}} 566 ) 567 568 func request_Query_Redelegations_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 569 var protoReq QueryRedelegationsRequest 570 var metadata runtime.ServerMetadata 571 572 var ( 573 val string 574 ok bool 575 err error 576 _ = err 577 ) 578 579 val, ok = pathParams["delegator_addr"] 580 if !ok { 581 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "delegator_addr") 582 } 583 584 protoReq.DelegatorAddr, err = runtime.String(val) 585 586 if err != nil { 587 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "delegator_addr", err) 588 } 589 590 if err := req.ParseForm(); err != nil { 591 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 592 } 593 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_Redelegations_0); err != nil { 594 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 595 } 596 597 msg, err := client.Redelegations(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 598 return msg, metadata, err 599 600 } 601 602 func local_request_Query_Redelegations_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 603 var protoReq QueryRedelegationsRequest 604 var metadata runtime.ServerMetadata 605 606 var ( 607 val string 608 ok bool 609 err error 610 _ = err 611 ) 612 613 val, ok = pathParams["delegator_addr"] 614 if !ok { 615 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "delegator_addr") 616 } 617 618 protoReq.DelegatorAddr, err = runtime.String(val) 619 620 if err != nil { 621 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "delegator_addr", err) 622 } 623 624 if err := req.ParseForm(); err != nil { 625 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 626 } 627 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_Redelegations_0); err != nil { 628 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 629 } 630 631 msg, err := server.Redelegations(ctx, &protoReq) 632 return msg, metadata, err 633 634 } 635 636 var ( 637 filter_Query_DelegatorValidators_0 = &utilities.DoubleArray{Encoding: map[string]int{"delegator_addr": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}} 638 ) 639 640 func request_Query_DelegatorValidators_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 641 var protoReq QueryDelegatorValidatorsRequest 642 var metadata runtime.ServerMetadata 643 644 var ( 645 val string 646 ok bool 647 err error 648 _ = err 649 ) 650 651 val, ok = pathParams["delegator_addr"] 652 if !ok { 653 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "delegator_addr") 654 } 655 656 protoReq.DelegatorAddr, err = runtime.String(val) 657 658 if err != nil { 659 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "delegator_addr", err) 660 } 661 662 if err := req.ParseForm(); err != nil { 663 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 664 } 665 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_DelegatorValidators_0); err != nil { 666 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 667 } 668 669 msg, err := client.DelegatorValidators(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 670 return msg, metadata, err 671 672 } 673 674 func local_request_Query_DelegatorValidators_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 675 var protoReq QueryDelegatorValidatorsRequest 676 var metadata runtime.ServerMetadata 677 678 var ( 679 val string 680 ok bool 681 err error 682 _ = err 683 ) 684 685 val, ok = pathParams["delegator_addr"] 686 if !ok { 687 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "delegator_addr") 688 } 689 690 protoReq.DelegatorAddr, err = runtime.String(val) 691 692 if err != nil { 693 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "delegator_addr", err) 694 } 695 696 if err := req.ParseForm(); err != nil { 697 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 698 } 699 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_DelegatorValidators_0); err != nil { 700 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 701 } 702 703 msg, err := server.DelegatorValidators(ctx, &protoReq) 704 return msg, metadata, err 705 706 } 707 708 func request_Query_DelegatorValidator_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 709 var protoReq QueryDelegatorValidatorRequest 710 var metadata runtime.ServerMetadata 711 712 var ( 713 val string 714 ok bool 715 err error 716 _ = err 717 ) 718 719 val, ok = pathParams["delegator_addr"] 720 if !ok { 721 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "delegator_addr") 722 } 723 724 protoReq.DelegatorAddr, err = runtime.String(val) 725 726 if err != nil { 727 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "delegator_addr", err) 728 } 729 730 val, ok = pathParams["validator_addr"] 731 if !ok { 732 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "validator_addr") 733 } 734 735 protoReq.ValidatorAddr, err = runtime.String(val) 736 737 if err != nil { 738 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "validator_addr", err) 739 } 740 741 msg, err := client.DelegatorValidator(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 742 return msg, metadata, err 743 744 } 745 746 func local_request_Query_DelegatorValidator_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 747 var protoReq QueryDelegatorValidatorRequest 748 var metadata runtime.ServerMetadata 749 750 var ( 751 val string 752 ok bool 753 err error 754 _ = err 755 ) 756 757 val, ok = pathParams["delegator_addr"] 758 if !ok { 759 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "delegator_addr") 760 } 761 762 protoReq.DelegatorAddr, err = runtime.String(val) 763 764 if err != nil { 765 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "delegator_addr", err) 766 } 767 768 val, ok = pathParams["validator_addr"] 769 if !ok { 770 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "validator_addr") 771 } 772 773 protoReq.ValidatorAddr, err = runtime.String(val) 774 775 if err != nil { 776 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "validator_addr", err) 777 } 778 779 msg, err := server.DelegatorValidator(ctx, &protoReq) 780 return msg, metadata, err 781 782 } 783 784 func request_Query_HistoricalInfo_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 785 var protoReq QueryHistoricalInfoRequest 786 var metadata runtime.ServerMetadata 787 788 var ( 789 val string 790 ok bool 791 err error 792 _ = err 793 ) 794 795 val, ok = pathParams["height"] 796 if !ok { 797 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "height") 798 } 799 800 protoReq.Height, err = runtime.Int64(val) 801 802 if err != nil { 803 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "height", err) 804 } 805 806 msg, err := client.HistoricalInfo(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 807 return msg, metadata, err 808 809 } 810 811 func local_request_Query_HistoricalInfo_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 812 var protoReq QueryHistoricalInfoRequest 813 var metadata runtime.ServerMetadata 814 815 var ( 816 val string 817 ok bool 818 err error 819 _ = err 820 ) 821 822 val, ok = pathParams["height"] 823 if !ok { 824 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "height") 825 } 826 827 protoReq.Height, err = runtime.Int64(val) 828 829 if err != nil { 830 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "height", err) 831 } 832 833 msg, err := server.HistoricalInfo(ctx, &protoReq) 834 return msg, metadata, err 835 836 } 837 838 func request_Query_Pool_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 839 var protoReq QueryPoolRequest 840 var metadata runtime.ServerMetadata 841 842 msg, err := client.Pool(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 843 return msg, metadata, err 844 845 } 846 847 func local_request_Query_Pool_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 848 var protoReq QueryPoolRequest 849 var metadata runtime.ServerMetadata 850 851 msg, err := server.Pool(ctx, &protoReq) 852 return msg, metadata, err 853 854 } 855 856 func request_Query_Params_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 857 var protoReq QueryParamsRequest 858 var metadata runtime.ServerMetadata 859 860 msg, err := client.Params(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 861 return msg, metadata, err 862 863 } 864 865 func local_request_Query_Params_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 866 var protoReq QueryParamsRequest 867 var metadata runtime.ServerMetadata 868 869 msg, err := server.Params(ctx, &protoReq) 870 return msg, metadata, err 871 872 } 873 874 // RegisterQueryHandlerServer registers the http handlers for service Query to "mux". 875 // UnaryRPC :call QueryServer directly. 876 // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. 877 // Note that using this registration option will cause many gRPC library features (such as grpc.SendHeader, etc) to stop working. Consider using RegisterQueryHandlerFromEndpoint instead. 878 func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, server QueryServer) error { 879 880 mux.Handle("GET", pattern_Query_Validators_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 881 ctx, cancel := context.WithCancel(req.Context()) 882 defer cancel() 883 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 884 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) 885 if err != nil { 886 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 887 return 888 } 889 resp, md, err := local_request_Query_Validators_0(rctx, inboundMarshaler, server, req, pathParams) 890 ctx = runtime.NewServerMetadataContext(ctx, md) 891 if err != nil { 892 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 893 return 894 } 895 896 forward_Query_Validators_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 897 898 }) 899 900 mux.Handle("GET", pattern_Query_Validator_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 901 ctx, cancel := context.WithCancel(req.Context()) 902 defer cancel() 903 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 904 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) 905 if err != nil { 906 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 907 return 908 } 909 resp, md, err := local_request_Query_Validator_0(rctx, inboundMarshaler, server, req, pathParams) 910 ctx = runtime.NewServerMetadataContext(ctx, md) 911 if err != nil { 912 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 913 return 914 } 915 916 forward_Query_Validator_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 917 918 }) 919 920 mux.Handle("GET", pattern_Query_ValidatorDelegations_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 921 ctx, cancel := context.WithCancel(req.Context()) 922 defer cancel() 923 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 924 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) 925 if err != nil { 926 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 927 return 928 } 929 resp, md, err := local_request_Query_ValidatorDelegations_0(rctx, inboundMarshaler, server, req, pathParams) 930 ctx = runtime.NewServerMetadataContext(ctx, md) 931 if err != nil { 932 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 933 return 934 } 935 936 forward_Query_ValidatorDelegations_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 937 938 }) 939 940 mux.Handle("GET", pattern_Query_ValidatorUnbondingDelegations_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 941 ctx, cancel := context.WithCancel(req.Context()) 942 defer cancel() 943 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 944 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) 945 if err != nil { 946 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 947 return 948 } 949 resp, md, err := local_request_Query_ValidatorUnbondingDelegations_0(rctx, inboundMarshaler, server, req, pathParams) 950 ctx = runtime.NewServerMetadataContext(ctx, md) 951 if err != nil { 952 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 953 return 954 } 955 956 forward_Query_ValidatorUnbondingDelegations_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 957 958 }) 959 960 mux.Handle("GET", pattern_Query_Delegation_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 961 ctx, cancel := context.WithCancel(req.Context()) 962 defer cancel() 963 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 964 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) 965 if err != nil { 966 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 967 return 968 } 969 resp, md, err := local_request_Query_Delegation_0(rctx, inboundMarshaler, server, req, pathParams) 970 ctx = runtime.NewServerMetadataContext(ctx, md) 971 if err != nil { 972 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 973 return 974 } 975 976 forward_Query_Delegation_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 977 978 }) 979 980 mux.Handle("GET", pattern_Query_UnbondingDelegation_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 981 ctx, cancel := context.WithCancel(req.Context()) 982 defer cancel() 983 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 984 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) 985 if err != nil { 986 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 987 return 988 } 989 resp, md, err := local_request_Query_UnbondingDelegation_0(rctx, inboundMarshaler, server, req, pathParams) 990 ctx = runtime.NewServerMetadataContext(ctx, md) 991 if err != nil { 992 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 993 return 994 } 995 996 forward_Query_UnbondingDelegation_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 997 998 }) 999 1000 mux.Handle("GET", pattern_Query_DelegatorDelegations_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1001 ctx, cancel := context.WithCancel(req.Context()) 1002 defer cancel() 1003 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1004 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) 1005 if err != nil { 1006 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1007 return 1008 } 1009 resp, md, err := local_request_Query_DelegatorDelegations_0(rctx, inboundMarshaler, server, req, pathParams) 1010 ctx = runtime.NewServerMetadataContext(ctx, md) 1011 if err != nil { 1012 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1013 return 1014 } 1015 1016 forward_Query_DelegatorDelegations_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1017 1018 }) 1019 1020 mux.Handle("GET", pattern_Query_DelegatorUnbondingDelegations_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1021 ctx, cancel := context.WithCancel(req.Context()) 1022 defer cancel() 1023 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1024 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) 1025 if err != nil { 1026 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1027 return 1028 } 1029 resp, md, err := local_request_Query_DelegatorUnbondingDelegations_0(rctx, inboundMarshaler, server, req, pathParams) 1030 ctx = runtime.NewServerMetadataContext(ctx, md) 1031 if err != nil { 1032 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1033 return 1034 } 1035 1036 forward_Query_DelegatorUnbondingDelegations_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1037 1038 }) 1039 1040 mux.Handle("GET", pattern_Query_Redelegations_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1041 ctx, cancel := context.WithCancel(req.Context()) 1042 defer cancel() 1043 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1044 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) 1045 if err != nil { 1046 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1047 return 1048 } 1049 resp, md, err := local_request_Query_Redelegations_0(rctx, inboundMarshaler, server, req, pathParams) 1050 ctx = runtime.NewServerMetadataContext(ctx, md) 1051 if err != nil { 1052 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1053 return 1054 } 1055 1056 forward_Query_Redelegations_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1057 1058 }) 1059 1060 mux.Handle("GET", pattern_Query_DelegatorValidators_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1061 ctx, cancel := context.WithCancel(req.Context()) 1062 defer cancel() 1063 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1064 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) 1065 if err != nil { 1066 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1067 return 1068 } 1069 resp, md, err := local_request_Query_DelegatorValidators_0(rctx, inboundMarshaler, server, req, pathParams) 1070 ctx = runtime.NewServerMetadataContext(ctx, md) 1071 if err != nil { 1072 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1073 return 1074 } 1075 1076 forward_Query_DelegatorValidators_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1077 1078 }) 1079 1080 mux.Handle("GET", pattern_Query_DelegatorValidator_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1081 ctx, cancel := context.WithCancel(req.Context()) 1082 defer cancel() 1083 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1084 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) 1085 if err != nil { 1086 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1087 return 1088 } 1089 resp, md, err := local_request_Query_DelegatorValidator_0(rctx, inboundMarshaler, server, req, pathParams) 1090 ctx = runtime.NewServerMetadataContext(ctx, md) 1091 if err != nil { 1092 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1093 return 1094 } 1095 1096 forward_Query_DelegatorValidator_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1097 1098 }) 1099 1100 mux.Handle("GET", pattern_Query_HistoricalInfo_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1101 ctx, cancel := context.WithCancel(req.Context()) 1102 defer cancel() 1103 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1104 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) 1105 if err != nil { 1106 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1107 return 1108 } 1109 resp, md, err := local_request_Query_HistoricalInfo_0(rctx, inboundMarshaler, server, req, pathParams) 1110 ctx = runtime.NewServerMetadataContext(ctx, md) 1111 if err != nil { 1112 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1113 return 1114 } 1115 1116 forward_Query_HistoricalInfo_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1117 1118 }) 1119 1120 mux.Handle("GET", pattern_Query_Pool_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1121 ctx, cancel := context.WithCancel(req.Context()) 1122 defer cancel() 1123 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1124 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) 1125 if err != nil { 1126 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1127 return 1128 } 1129 resp, md, err := local_request_Query_Pool_0(rctx, inboundMarshaler, server, req, pathParams) 1130 ctx = runtime.NewServerMetadataContext(ctx, md) 1131 if err != nil { 1132 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1133 return 1134 } 1135 1136 forward_Query_Pool_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1137 1138 }) 1139 1140 mux.Handle("GET", pattern_Query_Params_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1141 ctx, cancel := context.WithCancel(req.Context()) 1142 defer cancel() 1143 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1144 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) 1145 if err != nil { 1146 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1147 return 1148 } 1149 resp, md, err := local_request_Query_Params_0(rctx, inboundMarshaler, server, req, pathParams) 1150 ctx = runtime.NewServerMetadataContext(ctx, md) 1151 if err != nil { 1152 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1153 return 1154 } 1155 1156 forward_Query_Params_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1157 1158 }) 1159 1160 return nil 1161 } 1162 1163 // RegisterQueryHandlerFromEndpoint is same as RegisterQueryHandler but 1164 // automatically dials to "endpoint" and closes the connection when "ctx" gets done. 1165 func RegisterQueryHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) { 1166 conn, err := grpc.Dial(endpoint, opts...) 1167 if err != nil { 1168 return err 1169 } 1170 defer func() { 1171 if err != nil { 1172 if cerr := conn.Close(); cerr != nil { 1173 grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr) 1174 } 1175 return 1176 } 1177 go func() { 1178 <-ctx.Done() 1179 if cerr := conn.Close(); cerr != nil { 1180 grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr) 1181 } 1182 }() 1183 }() 1184 1185 return RegisterQueryHandler(ctx, mux, conn) 1186 } 1187 1188 // RegisterQueryHandler registers the http handlers for service Query to "mux". 1189 // The handlers forward requests to the grpc endpoint over "conn". 1190 func RegisterQueryHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error { 1191 return RegisterQueryHandlerClient(ctx, mux, NewQueryClient(conn)) 1192 } 1193 1194 // RegisterQueryHandlerClient registers the http handlers for service Query 1195 // to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "QueryClient". 1196 // Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "QueryClient" 1197 // doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in 1198 // "QueryClient" to call the correct interceptors. 1199 func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, client QueryClient) error { 1200 1201 mux.Handle("GET", pattern_Query_Validators_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1202 ctx, cancel := context.WithCancel(req.Context()) 1203 defer cancel() 1204 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1205 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1206 if err != nil { 1207 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1208 return 1209 } 1210 resp, md, err := request_Query_Validators_0(rctx, inboundMarshaler, client, req, pathParams) 1211 ctx = runtime.NewServerMetadataContext(ctx, md) 1212 if err != nil { 1213 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1214 return 1215 } 1216 1217 forward_Query_Validators_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1218 1219 }) 1220 1221 mux.Handle("GET", pattern_Query_Validator_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1222 ctx, cancel := context.WithCancel(req.Context()) 1223 defer cancel() 1224 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1225 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1226 if err != nil { 1227 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1228 return 1229 } 1230 resp, md, err := request_Query_Validator_0(rctx, inboundMarshaler, client, req, pathParams) 1231 ctx = runtime.NewServerMetadataContext(ctx, md) 1232 if err != nil { 1233 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1234 return 1235 } 1236 1237 forward_Query_Validator_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1238 1239 }) 1240 1241 mux.Handle("GET", pattern_Query_ValidatorDelegations_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1242 ctx, cancel := context.WithCancel(req.Context()) 1243 defer cancel() 1244 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1245 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1246 if err != nil { 1247 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1248 return 1249 } 1250 resp, md, err := request_Query_ValidatorDelegations_0(rctx, inboundMarshaler, client, req, pathParams) 1251 ctx = runtime.NewServerMetadataContext(ctx, md) 1252 if err != nil { 1253 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1254 return 1255 } 1256 1257 forward_Query_ValidatorDelegations_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1258 1259 }) 1260 1261 mux.Handle("GET", pattern_Query_ValidatorUnbondingDelegations_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1262 ctx, cancel := context.WithCancel(req.Context()) 1263 defer cancel() 1264 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1265 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1266 if err != nil { 1267 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1268 return 1269 } 1270 resp, md, err := request_Query_ValidatorUnbondingDelegations_0(rctx, inboundMarshaler, client, req, pathParams) 1271 ctx = runtime.NewServerMetadataContext(ctx, md) 1272 if err != nil { 1273 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1274 return 1275 } 1276 1277 forward_Query_ValidatorUnbondingDelegations_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1278 1279 }) 1280 1281 mux.Handle("GET", pattern_Query_Delegation_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1282 ctx, cancel := context.WithCancel(req.Context()) 1283 defer cancel() 1284 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1285 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1286 if err != nil { 1287 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1288 return 1289 } 1290 resp, md, err := request_Query_Delegation_0(rctx, inboundMarshaler, client, req, pathParams) 1291 ctx = runtime.NewServerMetadataContext(ctx, md) 1292 if err != nil { 1293 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1294 return 1295 } 1296 1297 forward_Query_Delegation_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1298 1299 }) 1300 1301 mux.Handle("GET", pattern_Query_UnbondingDelegation_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1302 ctx, cancel := context.WithCancel(req.Context()) 1303 defer cancel() 1304 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1305 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1306 if err != nil { 1307 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1308 return 1309 } 1310 resp, md, err := request_Query_UnbondingDelegation_0(rctx, inboundMarshaler, client, req, pathParams) 1311 ctx = runtime.NewServerMetadataContext(ctx, md) 1312 if err != nil { 1313 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1314 return 1315 } 1316 1317 forward_Query_UnbondingDelegation_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1318 1319 }) 1320 1321 mux.Handle("GET", pattern_Query_DelegatorDelegations_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1322 ctx, cancel := context.WithCancel(req.Context()) 1323 defer cancel() 1324 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1325 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1326 if err != nil { 1327 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1328 return 1329 } 1330 resp, md, err := request_Query_DelegatorDelegations_0(rctx, inboundMarshaler, client, req, pathParams) 1331 ctx = runtime.NewServerMetadataContext(ctx, md) 1332 if err != nil { 1333 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1334 return 1335 } 1336 1337 forward_Query_DelegatorDelegations_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1338 1339 }) 1340 1341 mux.Handle("GET", pattern_Query_DelegatorUnbondingDelegations_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1342 ctx, cancel := context.WithCancel(req.Context()) 1343 defer cancel() 1344 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1345 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1346 if err != nil { 1347 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1348 return 1349 } 1350 resp, md, err := request_Query_DelegatorUnbondingDelegations_0(rctx, inboundMarshaler, client, req, pathParams) 1351 ctx = runtime.NewServerMetadataContext(ctx, md) 1352 if err != nil { 1353 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1354 return 1355 } 1356 1357 forward_Query_DelegatorUnbondingDelegations_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1358 1359 }) 1360 1361 mux.Handle("GET", pattern_Query_Redelegations_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1362 ctx, cancel := context.WithCancel(req.Context()) 1363 defer cancel() 1364 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1365 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1366 if err != nil { 1367 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1368 return 1369 } 1370 resp, md, err := request_Query_Redelegations_0(rctx, inboundMarshaler, client, req, pathParams) 1371 ctx = runtime.NewServerMetadataContext(ctx, md) 1372 if err != nil { 1373 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1374 return 1375 } 1376 1377 forward_Query_Redelegations_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1378 1379 }) 1380 1381 mux.Handle("GET", pattern_Query_DelegatorValidators_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1382 ctx, cancel := context.WithCancel(req.Context()) 1383 defer cancel() 1384 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1385 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1386 if err != nil { 1387 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1388 return 1389 } 1390 resp, md, err := request_Query_DelegatorValidators_0(rctx, inboundMarshaler, client, req, pathParams) 1391 ctx = runtime.NewServerMetadataContext(ctx, md) 1392 if err != nil { 1393 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1394 return 1395 } 1396 1397 forward_Query_DelegatorValidators_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1398 1399 }) 1400 1401 mux.Handle("GET", pattern_Query_DelegatorValidator_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1402 ctx, cancel := context.WithCancel(req.Context()) 1403 defer cancel() 1404 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1405 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1406 if err != nil { 1407 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1408 return 1409 } 1410 resp, md, err := request_Query_DelegatorValidator_0(rctx, inboundMarshaler, client, req, pathParams) 1411 ctx = runtime.NewServerMetadataContext(ctx, md) 1412 if err != nil { 1413 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1414 return 1415 } 1416 1417 forward_Query_DelegatorValidator_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1418 1419 }) 1420 1421 mux.Handle("GET", pattern_Query_HistoricalInfo_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1422 ctx, cancel := context.WithCancel(req.Context()) 1423 defer cancel() 1424 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1425 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1426 if err != nil { 1427 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1428 return 1429 } 1430 resp, md, err := request_Query_HistoricalInfo_0(rctx, inboundMarshaler, client, req, pathParams) 1431 ctx = runtime.NewServerMetadataContext(ctx, md) 1432 if err != nil { 1433 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1434 return 1435 } 1436 1437 forward_Query_HistoricalInfo_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1438 1439 }) 1440 1441 mux.Handle("GET", pattern_Query_Pool_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1442 ctx, cancel := context.WithCancel(req.Context()) 1443 defer cancel() 1444 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1445 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1446 if err != nil { 1447 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1448 return 1449 } 1450 resp, md, err := request_Query_Pool_0(rctx, inboundMarshaler, client, req, pathParams) 1451 ctx = runtime.NewServerMetadataContext(ctx, md) 1452 if err != nil { 1453 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1454 return 1455 } 1456 1457 forward_Query_Pool_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1458 1459 }) 1460 1461 mux.Handle("GET", pattern_Query_Params_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1462 ctx, cancel := context.WithCancel(req.Context()) 1463 defer cancel() 1464 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1465 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1466 if err != nil { 1467 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1468 return 1469 } 1470 resp, md, err := request_Query_Params_0(rctx, inboundMarshaler, client, req, pathParams) 1471 ctx = runtime.NewServerMetadataContext(ctx, md) 1472 if err != nil { 1473 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1474 return 1475 } 1476 1477 forward_Query_Params_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1478 1479 }) 1480 1481 return nil 1482 } 1483 1484 var ( 1485 pattern_Query_Validators_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"cosmos", "staking", "v1beta1", "validators"}, "", runtime.AssumeColonVerbOpt(false))) 1486 1487 pattern_Query_Validator_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"cosmos", "staking", "v1beta1", "validators", "validator_addr"}, "", runtime.AssumeColonVerbOpt(false))) 1488 1489 pattern_Query_ValidatorDelegations_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 2, 5}, []string{"cosmos", "staking", "v1beta1", "validators", "validator_addr", "delegations"}, "", runtime.AssumeColonVerbOpt(false))) 1490 1491 pattern_Query_ValidatorUnbondingDelegations_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 2, 5}, []string{"cosmos", "staking", "v1beta1", "validators", "validator_addr", "unbonding_delegations"}, "", runtime.AssumeColonVerbOpt(false))) 1492 1493 pattern_Query_Delegation_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 2, 5, 1, 0, 4, 1, 5, 6}, []string{"cosmos", "staking", "v1beta1", "validators", "validator_addr", "delegations", "delegator_addr"}, "", runtime.AssumeColonVerbOpt(false))) 1494 1495 pattern_Query_UnbondingDelegation_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 2, 5, 1, 0, 4, 1, 5, 6, 2, 7}, []string{"cosmos", "staking", "v1beta1", "validators", "validator_addr", "delegations", "delegator_addr", "unbonding_delegation"}, "", runtime.AssumeColonVerbOpt(false))) 1496 1497 pattern_Query_DelegatorDelegations_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"cosmos", "staking", "v1beta1", "delegations", "delegator_addr"}, "", runtime.AssumeColonVerbOpt(false))) 1498 1499 pattern_Query_DelegatorUnbondingDelegations_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 2, 5}, []string{"cosmos", "staking", "v1beta1", "delegators", "delegator_addr", "unbonding_delegations"}, "", runtime.AssumeColonVerbOpt(false))) 1500 1501 pattern_Query_Redelegations_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 2, 5}, []string{"cosmos", "staking", "v1beta1", "delegators", "delegator_addr", "redelegations"}, "", runtime.AssumeColonVerbOpt(false))) 1502 1503 pattern_Query_DelegatorValidators_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 2, 5}, []string{"cosmos", "staking", "v1beta1", "delegators", "delegator_addr", "validators"}, "", runtime.AssumeColonVerbOpt(false))) 1504 1505 pattern_Query_DelegatorValidator_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 2, 5, 1, 0, 4, 1, 5, 6}, []string{"cosmos", "staking", "v1beta1", "delegators", "delegator_addr", "validators", "validator_addr"}, "", runtime.AssumeColonVerbOpt(false))) 1506 1507 pattern_Query_HistoricalInfo_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"cosmos", "staking", "v1beta1", "historical_info", "height"}, "", runtime.AssumeColonVerbOpt(false))) 1508 1509 pattern_Query_Pool_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"cosmos", "staking", "v1beta1", "pool"}, "", runtime.AssumeColonVerbOpt(false))) 1510 1511 pattern_Query_Params_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"cosmos", "staking", "v1beta1", "params"}, "", runtime.AssumeColonVerbOpt(false))) 1512 ) 1513 1514 var ( 1515 forward_Query_Validators_0 = runtime.ForwardResponseMessage 1516 1517 forward_Query_Validator_0 = runtime.ForwardResponseMessage 1518 1519 forward_Query_ValidatorDelegations_0 = runtime.ForwardResponseMessage 1520 1521 forward_Query_ValidatorUnbondingDelegations_0 = runtime.ForwardResponseMessage 1522 1523 forward_Query_Delegation_0 = runtime.ForwardResponseMessage 1524 1525 forward_Query_UnbondingDelegation_0 = runtime.ForwardResponseMessage 1526 1527 forward_Query_DelegatorDelegations_0 = runtime.ForwardResponseMessage 1528 1529 forward_Query_DelegatorUnbondingDelegations_0 = runtime.ForwardResponseMessage 1530 1531 forward_Query_Redelegations_0 = runtime.ForwardResponseMessage 1532 1533 forward_Query_DelegatorValidators_0 = runtime.ForwardResponseMessage 1534 1535 forward_Query_DelegatorValidator_0 = runtime.ForwardResponseMessage 1536 1537 forward_Query_HistoricalInfo_0 = runtime.ForwardResponseMessage 1538 1539 forward_Query_Pool_0 = runtime.ForwardResponseMessage 1540 1541 forward_Query_Params_0 = runtime.ForwardResponseMessage 1542 )