github.com/igggame/nebulas-go@v2.1.0+incompatible/rpc/pb/rpc.pb.gw.go (about) 1 // Code generated by protoc-gen-grpc-gateway. DO NOT EDIT. 2 // source: rpc.proto 3 4 /* 5 Package rpcpb is a reverse proxy. 6 7 It translates gRPC into RESTful JSON APIs. 8 */ 9 package rpcpb 10 11 import ( 12 "io" 13 "net/http" 14 15 "github.com/golang/protobuf/proto" 16 "github.com/nebulasio/grpc-gateway/runtime" 17 "github.com/nebulasio/grpc-gateway/utilities" 18 "golang.org/x/net/context" 19 "google.golang.org/grpc" 20 "google.golang.org/grpc/codes" 21 "google.golang.org/grpc/grpclog" 22 "google.golang.org/grpc/status" 23 ) 24 25 var _ codes.Code 26 var _ io.Reader 27 var _ status.Status 28 var _ = runtime.String 29 var _ = utilities.NewDoubleArray 30 31 func request_ApiService_GetNebState_0(ctx context.Context, marshaler runtime.Marshaler, client ApiServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 32 var protoReq NonParamsRequest 33 var metadata runtime.ServerMetadata 34 35 msg, err := client.GetNebState(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 36 return msg, metadata, err 37 38 } 39 40 func request_ApiService_LatestIrreversibleBlock_0(ctx context.Context, marshaler runtime.Marshaler, client ApiServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 41 var protoReq NonParamsRequest 42 var metadata runtime.ServerMetadata 43 44 msg, err := client.LatestIrreversibleBlock(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 45 return msg, metadata, err 46 47 } 48 49 func request_ApiService_GetAccountState_0(ctx context.Context, marshaler runtime.Marshaler, client ApiServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 50 var protoReq GetAccountStateRequest 51 var metadata runtime.ServerMetadata 52 53 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 54 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 55 } 56 57 msg, err := client.GetAccountState(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 58 return msg, metadata, err 59 60 } 61 62 func request_ApiService_Call_0(ctx context.Context, marshaler runtime.Marshaler, client ApiServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 63 var protoReq TransactionRequest 64 var metadata runtime.ServerMetadata 65 66 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 67 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 68 } 69 70 msg, err := client.Call(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 71 return msg, metadata, err 72 73 } 74 75 func request_ApiService_SendRawTransaction_0(ctx context.Context, marshaler runtime.Marshaler, client ApiServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 76 var protoReq SendRawTransactionRequest 77 var metadata runtime.ServerMetadata 78 79 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 80 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 81 } 82 83 msg, err := client.SendRawTransaction(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 84 return msg, metadata, err 85 86 } 87 88 func request_ApiService_GetBlockByHash_0(ctx context.Context, marshaler runtime.Marshaler, client ApiServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 89 var protoReq GetBlockByHashRequest 90 var metadata runtime.ServerMetadata 91 92 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 93 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 94 } 95 96 msg, err := client.GetBlockByHash(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 97 return msg, metadata, err 98 99 } 100 101 func request_ApiService_GetBlockByHeight_0(ctx context.Context, marshaler runtime.Marshaler, client ApiServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 102 var protoReq GetBlockByHeightRequest 103 var metadata runtime.ServerMetadata 104 105 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 106 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 107 } 108 109 msg, err := client.GetBlockByHeight(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 110 return msg, metadata, err 111 112 } 113 114 func request_ApiService_GetTransactionReceipt_0(ctx context.Context, marshaler runtime.Marshaler, client ApiServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 115 var protoReq GetTransactionByHashRequest 116 var metadata runtime.ServerMetadata 117 118 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 119 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 120 } 121 122 msg, err := client.GetTransactionReceipt(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 123 return msg, metadata, err 124 125 } 126 127 func request_ApiService_GetTransactionByContract_0(ctx context.Context, marshaler runtime.Marshaler, client ApiServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 128 var protoReq GetTransactionByContractRequest 129 var metadata runtime.ServerMetadata 130 131 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 132 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 133 } 134 135 msg, err := client.GetTransactionByContract(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 136 return msg, metadata, err 137 138 } 139 140 func request_ApiService_Subscribe_0(ctx context.Context, marshaler runtime.Marshaler, client ApiServiceClient, req *http.Request, pathParams map[string]string) (ApiService_SubscribeClient, runtime.ServerMetadata, error) { 141 var protoReq SubscribeRequest 142 var metadata runtime.ServerMetadata 143 144 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 145 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 146 } 147 148 stream, err := client.Subscribe(ctx, &protoReq) 149 if err != nil { 150 return nil, metadata, err 151 } 152 header, err := stream.Header() 153 if err != nil { 154 return nil, metadata, err 155 } 156 metadata.HeaderMD = header 157 return stream, metadata, nil 158 159 } 160 161 func request_ApiService_GetGasPrice_0(ctx context.Context, marshaler runtime.Marshaler, client ApiServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 162 var protoReq NonParamsRequest 163 var metadata runtime.ServerMetadata 164 165 msg, err := client.GetGasPrice(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 166 return msg, metadata, err 167 168 } 169 170 func request_ApiService_EstimateGas_0(ctx context.Context, marshaler runtime.Marshaler, client ApiServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 171 var protoReq TransactionRequest 172 var metadata runtime.ServerMetadata 173 174 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 175 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 176 } 177 178 msg, err := client.EstimateGas(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 179 return msg, metadata, err 180 181 } 182 183 func request_ApiService_GetEventsByHash_0(ctx context.Context, marshaler runtime.Marshaler, client ApiServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 184 var protoReq HashRequest 185 var metadata runtime.ServerMetadata 186 187 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 188 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 189 } 190 191 msg, err := client.GetEventsByHash(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 192 return msg, metadata, err 193 194 } 195 196 func request_ApiService_GetDynasty_0(ctx context.Context, marshaler runtime.Marshaler, client ApiServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 197 var protoReq ByBlockHeightRequest 198 var metadata runtime.ServerMetadata 199 200 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 201 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 202 } 203 204 msg, err := client.GetDynasty(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 205 return msg, metadata, err 206 207 } 208 209 func request_ApiService_VerifySignature_0(ctx context.Context, marshaler runtime.Marshaler, client ApiServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 210 var protoReq VerifySignatureRequest 211 var metadata runtime.ServerMetadata 212 213 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 214 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 215 } 216 217 msg, err := client.VerifySignature(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 218 return msg, metadata, err 219 220 } 221 222 func request_AdminService_Accounts_0(ctx context.Context, marshaler runtime.Marshaler, client AdminServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 223 var protoReq NonParamsRequest 224 var metadata runtime.ServerMetadata 225 226 msg, err := client.Accounts(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 227 return msg, metadata, err 228 229 } 230 231 func request_AdminService_NewAccount_0(ctx context.Context, marshaler runtime.Marshaler, client AdminServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 232 var protoReq NewAccountRequest 233 var metadata runtime.ServerMetadata 234 235 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 236 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 237 } 238 239 msg, err := client.NewAccount(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 240 return msg, metadata, err 241 242 } 243 244 func request_AdminService_UnlockAccount_0(ctx context.Context, marshaler runtime.Marshaler, client AdminServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 245 var protoReq UnlockAccountRequest 246 var metadata runtime.ServerMetadata 247 248 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 249 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 250 } 251 252 msg, err := client.UnlockAccount(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 253 return msg, metadata, err 254 255 } 256 257 func request_AdminService_LockAccount_0(ctx context.Context, marshaler runtime.Marshaler, client AdminServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 258 var protoReq LockAccountRequest 259 var metadata runtime.ServerMetadata 260 261 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 262 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 263 } 264 265 msg, err := client.LockAccount(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 266 return msg, metadata, err 267 268 } 269 270 func request_AdminService_SendTransaction_0(ctx context.Context, marshaler runtime.Marshaler, client AdminServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 271 var protoReq TransactionRequest 272 var metadata runtime.ServerMetadata 273 274 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 275 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 276 } 277 278 msg, err := client.SendTransaction(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 279 return msg, metadata, err 280 281 } 282 283 func request_AdminService_SignHash_0(ctx context.Context, marshaler runtime.Marshaler, client AdminServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 284 var protoReq SignHashRequest 285 var metadata runtime.ServerMetadata 286 287 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 288 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 289 } 290 291 msg, err := client.SignHash(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 292 return msg, metadata, err 293 294 } 295 296 func request_AdminService_GenerateRandomSeed_0(ctx context.Context, marshaler runtime.Marshaler, client AdminServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 297 var protoReq GenerateRandomSeedRequest 298 var metadata runtime.ServerMetadata 299 300 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 301 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 302 } 303 304 msg, err := client.GenerateRandomSeed(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 305 return msg, metadata, err 306 307 } 308 309 func request_AdminService_SignTransactionWithPassphrase_0(ctx context.Context, marshaler runtime.Marshaler, client AdminServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 310 var protoReq SignTransactionPassphraseRequest 311 var metadata runtime.ServerMetadata 312 313 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 314 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 315 } 316 317 msg, err := client.SignTransactionWithPassphrase(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 318 return msg, metadata, err 319 320 } 321 322 func request_AdminService_SendTransactionWithPassphrase_0(ctx context.Context, marshaler runtime.Marshaler, client AdminServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 323 var protoReq SendTransactionPassphraseRequest 324 var metadata runtime.ServerMetadata 325 326 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 327 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 328 } 329 330 msg, err := client.SendTransactionWithPassphrase(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 331 return msg, metadata, err 332 333 } 334 335 func request_AdminService_StartPprof_0(ctx context.Context, marshaler runtime.Marshaler, client AdminServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 336 var protoReq PprofRequest 337 var metadata runtime.ServerMetadata 338 339 if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil { 340 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 341 } 342 343 msg, err := client.StartPprof(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 344 return msg, metadata, err 345 346 } 347 348 func request_AdminService_GetConfig_0(ctx context.Context, marshaler runtime.Marshaler, client AdminServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 349 var protoReq NonParamsRequest 350 var metadata runtime.ServerMetadata 351 352 msg, err := client.GetConfig(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 353 return msg, metadata, err 354 355 } 356 357 func request_AdminService_NodeInfo_0(ctx context.Context, marshaler runtime.Marshaler, client AdminServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 358 var protoReq NonParamsRequest 359 var metadata runtime.ServerMetadata 360 361 msg, err := client.NodeInfo(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 362 return msg, metadata, err 363 364 } 365 366 // RegisterApiServiceHandlerFromEndpoint is same as RegisterApiServiceHandler but 367 // automatically dials to "endpoint" and closes the connection when "ctx" gets done. 368 func RegisterApiServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) { 369 conn, err := grpc.Dial(endpoint, opts...) 370 if err != nil { 371 return err 372 } 373 defer func() { 374 if err != nil { 375 if cerr := conn.Close(); cerr != nil { 376 grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr) 377 } 378 return 379 } 380 go func() { 381 <-ctx.Done() 382 if cerr := conn.Close(); cerr != nil { 383 grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr) 384 } 385 }() 386 }() 387 388 return RegisterApiServiceHandler(ctx, mux, conn) 389 } 390 391 // RegisterApiServiceHandler registers the http handlers for service ApiService to "mux". 392 // The handlers forward requests to the grpc endpoint over "conn". 393 func RegisterApiServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error { 394 return RegisterApiServiceHandlerClient(ctx, mux, NewApiServiceClient(conn)) 395 } 396 397 // RegisterApiServiceHandler registers the http handlers for service ApiService to "mux". 398 // The handlers forward requests to the grpc endpoint over the given implementation of "ApiServiceClient". 399 // Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "ApiServiceClient" 400 // doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in 401 // "ApiServiceClient" to call the correct interceptors. 402 func RegisterApiServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client ApiServiceClient) error { 403 404 mux.Handle("GET", pattern_ApiService_GetNebState_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 405 ctx, cancel := context.WithCancel(ctx) 406 defer cancel() 407 if cn, ok := w.(http.CloseNotifier); ok { 408 go func(done <-chan struct{}, closed <-chan bool) { 409 select { 410 case <-done: 411 case <-closed: 412 cancel() 413 } 414 }(ctx.Done(), cn.CloseNotify()) 415 } 416 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 417 rctx, err := runtime.AnnotateContext(ctx, mux, req) 418 if err != nil { 419 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 420 return 421 } 422 resp, md, err := request_ApiService_GetNebState_0(rctx, inboundMarshaler, client, req, pathParams) 423 ctx = runtime.NewServerMetadataContext(ctx, md) 424 if err != nil { 425 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 426 return 427 } 428 429 forward_ApiService_GetNebState_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 430 431 }) 432 433 mux.Handle("GET", pattern_ApiService_LatestIrreversibleBlock_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 434 ctx, cancel := context.WithCancel(ctx) 435 defer cancel() 436 if cn, ok := w.(http.CloseNotifier); ok { 437 go func(done <-chan struct{}, closed <-chan bool) { 438 select { 439 case <-done: 440 case <-closed: 441 cancel() 442 } 443 }(ctx.Done(), cn.CloseNotify()) 444 } 445 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 446 rctx, err := runtime.AnnotateContext(ctx, mux, req) 447 if err != nil { 448 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 449 return 450 } 451 resp, md, err := request_ApiService_LatestIrreversibleBlock_0(rctx, inboundMarshaler, client, req, pathParams) 452 ctx = runtime.NewServerMetadataContext(ctx, md) 453 if err != nil { 454 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 455 return 456 } 457 458 forward_ApiService_LatestIrreversibleBlock_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 459 460 }) 461 462 mux.Handle("POST", pattern_ApiService_GetAccountState_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 463 ctx, cancel := context.WithCancel(ctx) 464 defer cancel() 465 if cn, ok := w.(http.CloseNotifier); ok { 466 go func(done <-chan struct{}, closed <-chan bool) { 467 select { 468 case <-done: 469 case <-closed: 470 cancel() 471 } 472 }(ctx.Done(), cn.CloseNotify()) 473 } 474 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 475 rctx, err := runtime.AnnotateContext(ctx, mux, req) 476 if err != nil { 477 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 478 return 479 } 480 resp, md, err := request_ApiService_GetAccountState_0(rctx, inboundMarshaler, client, req, pathParams) 481 ctx = runtime.NewServerMetadataContext(ctx, md) 482 if err != nil { 483 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 484 return 485 } 486 487 forward_ApiService_GetAccountState_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 488 489 }) 490 491 mux.Handle("POST", pattern_ApiService_Call_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 492 ctx, cancel := context.WithCancel(ctx) 493 defer cancel() 494 if cn, ok := w.(http.CloseNotifier); ok { 495 go func(done <-chan struct{}, closed <-chan bool) { 496 select { 497 case <-done: 498 case <-closed: 499 cancel() 500 } 501 }(ctx.Done(), cn.CloseNotify()) 502 } 503 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 504 rctx, err := runtime.AnnotateContext(ctx, mux, req) 505 if err != nil { 506 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 507 return 508 } 509 resp, md, err := request_ApiService_Call_0(rctx, inboundMarshaler, client, req, pathParams) 510 ctx = runtime.NewServerMetadataContext(ctx, md) 511 if err != nil { 512 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 513 return 514 } 515 516 forward_ApiService_Call_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 517 518 }) 519 520 mux.Handle("POST", pattern_ApiService_SendRawTransaction_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 521 ctx, cancel := context.WithCancel(ctx) 522 defer cancel() 523 if cn, ok := w.(http.CloseNotifier); ok { 524 go func(done <-chan struct{}, closed <-chan bool) { 525 select { 526 case <-done: 527 case <-closed: 528 cancel() 529 } 530 }(ctx.Done(), cn.CloseNotify()) 531 } 532 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 533 rctx, err := runtime.AnnotateContext(ctx, mux, req) 534 if err != nil { 535 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 536 return 537 } 538 resp, md, err := request_ApiService_SendRawTransaction_0(rctx, inboundMarshaler, client, req, pathParams) 539 ctx = runtime.NewServerMetadataContext(ctx, md) 540 if err != nil { 541 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 542 return 543 } 544 545 forward_ApiService_SendRawTransaction_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 546 547 }) 548 549 mux.Handle("POST", pattern_ApiService_GetBlockByHash_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 550 ctx, cancel := context.WithCancel(ctx) 551 defer cancel() 552 if cn, ok := w.(http.CloseNotifier); ok { 553 go func(done <-chan struct{}, closed <-chan bool) { 554 select { 555 case <-done: 556 case <-closed: 557 cancel() 558 } 559 }(ctx.Done(), cn.CloseNotify()) 560 } 561 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 562 rctx, err := runtime.AnnotateContext(ctx, mux, req) 563 if err != nil { 564 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 565 return 566 } 567 resp, md, err := request_ApiService_GetBlockByHash_0(rctx, inboundMarshaler, client, req, pathParams) 568 ctx = runtime.NewServerMetadataContext(ctx, md) 569 if err != nil { 570 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 571 return 572 } 573 574 forward_ApiService_GetBlockByHash_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 575 576 }) 577 578 mux.Handle("POST", pattern_ApiService_GetBlockByHeight_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 579 ctx, cancel := context.WithCancel(ctx) 580 defer cancel() 581 if cn, ok := w.(http.CloseNotifier); ok { 582 go func(done <-chan struct{}, closed <-chan bool) { 583 select { 584 case <-done: 585 case <-closed: 586 cancel() 587 } 588 }(ctx.Done(), cn.CloseNotify()) 589 } 590 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 591 rctx, err := runtime.AnnotateContext(ctx, mux, req) 592 if err != nil { 593 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 594 return 595 } 596 resp, md, err := request_ApiService_GetBlockByHeight_0(rctx, inboundMarshaler, client, req, pathParams) 597 ctx = runtime.NewServerMetadataContext(ctx, md) 598 if err != nil { 599 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 600 return 601 } 602 603 forward_ApiService_GetBlockByHeight_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 604 605 }) 606 607 mux.Handle("POST", pattern_ApiService_GetTransactionReceipt_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 608 ctx, cancel := context.WithCancel(ctx) 609 defer cancel() 610 if cn, ok := w.(http.CloseNotifier); ok { 611 go func(done <-chan struct{}, closed <-chan bool) { 612 select { 613 case <-done: 614 case <-closed: 615 cancel() 616 } 617 }(ctx.Done(), cn.CloseNotify()) 618 } 619 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 620 rctx, err := runtime.AnnotateContext(ctx, mux, req) 621 if err != nil { 622 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 623 return 624 } 625 resp, md, err := request_ApiService_GetTransactionReceipt_0(rctx, inboundMarshaler, client, req, pathParams) 626 ctx = runtime.NewServerMetadataContext(ctx, md) 627 if err != nil { 628 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 629 return 630 } 631 632 forward_ApiService_GetTransactionReceipt_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 633 634 }) 635 636 mux.Handle("POST", pattern_ApiService_GetTransactionByContract_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 637 ctx, cancel := context.WithCancel(ctx) 638 defer cancel() 639 if cn, ok := w.(http.CloseNotifier); ok { 640 go func(done <-chan struct{}, closed <-chan bool) { 641 select { 642 case <-done: 643 case <-closed: 644 cancel() 645 } 646 }(ctx.Done(), cn.CloseNotify()) 647 } 648 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 649 rctx, err := runtime.AnnotateContext(ctx, mux, req) 650 if err != nil { 651 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 652 return 653 } 654 resp, md, err := request_ApiService_GetTransactionByContract_0(rctx, inboundMarshaler, client, req, pathParams) 655 ctx = runtime.NewServerMetadataContext(ctx, md) 656 if err != nil { 657 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 658 return 659 } 660 661 forward_ApiService_GetTransactionByContract_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 662 663 }) 664 665 mux.Handle("POST", pattern_ApiService_Subscribe_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 666 ctx, cancel := context.WithCancel(ctx) 667 defer cancel() 668 if cn, ok := w.(http.CloseNotifier); ok { 669 go func(done <-chan struct{}, closed <-chan bool) { 670 select { 671 case <-done: 672 case <-closed: 673 cancel() 674 } 675 }(ctx.Done(), cn.CloseNotify()) 676 } 677 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 678 rctx, err := runtime.AnnotateContext(ctx, mux, req) 679 if err != nil { 680 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 681 return 682 } 683 resp, md, err := request_ApiService_Subscribe_0(rctx, inboundMarshaler, client, req, pathParams) 684 ctx = runtime.NewServerMetadataContext(ctx, md) 685 if err != nil { 686 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 687 return 688 } 689 690 forward_ApiService_Subscribe_0(ctx, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...) 691 692 }) 693 694 mux.Handle("GET", pattern_ApiService_GetGasPrice_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 695 ctx, cancel := context.WithCancel(ctx) 696 defer cancel() 697 if cn, ok := w.(http.CloseNotifier); ok { 698 go func(done <-chan struct{}, closed <-chan bool) { 699 select { 700 case <-done: 701 case <-closed: 702 cancel() 703 } 704 }(ctx.Done(), cn.CloseNotify()) 705 } 706 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 707 rctx, err := runtime.AnnotateContext(ctx, mux, req) 708 if err != nil { 709 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 710 return 711 } 712 resp, md, err := request_ApiService_GetGasPrice_0(rctx, inboundMarshaler, client, req, pathParams) 713 ctx = runtime.NewServerMetadataContext(ctx, md) 714 if err != nil { 715 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 716 return 717 } 718 719 forward_ApiService_GetGasPrice_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 720 721 }) 722 723 mux.Handle("POST", pattern_ApiService_EstimateGas_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 724 ctx, cancel := context.WithCancel(ctx) 725 defer cancel() 726 if cn, ok := w.(http.CloseNotifier); ok { 727 go func(done <-chan struct{}, closed <-chan bool) { 728 select { 729 case <-done: 730 case <-closed: 731 cancel() 732 } 733 }(ctx.Done(), cn.CloseNotify()) 734 } 735 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 736 rctx, err := runtime.AnnotateContext(ctx, mux, req) 737 if err != nil { 738 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 739 return 740 } 741 resp, md, err := request_ApiService_EstimateGas_0(rctx, inboundMarshaler, client, req, pathParams) 742 ctx = runtime.NewServerMetadataContext(ctx, md) 743 if err != nil { 744 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 745 return 746 } 747 748 forward_ApiService_EstimateGas_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 749 750 }) 751 752 mux.Handle("POST", pattern_ApiService_GetEventsByHash_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 753 ctx, cancel := context.WithCancel(ctx) 754 defer cancel() 755 if cn, ok := w.(http.CloseNotifier); ok { 756 go func(done <-chan struct{}, closed <-chan bool) { 757 select { 758 case <-done: 759 case <-closed: 760 cancel() 761 } 762 }(ctx.Done(), cn.CloseNotify()) 763 } 764 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 765 rctx, err := runtime.AnnotateContext(ctx, mux, req) 766 if err != nil { 767 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 768 return 769 } 770 resp, md, err := request_ApiService_GetEventsByHash_0(rctx, inboundMarshaler, client, req, pathParams) 771 ctx = runtime.NewServerMetadataContext(ctx, md) 772 if err != nil { 773 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 774 return 775 } 776 777 forward_ApiService_GetEventsByHash_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 778 779 }) 780 781 mux.Handle("POST", pattern_ApiService_GetDynasty_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 782 ctx, cancel := context.WithCancel(ctx) 783 defer cancel() 784 if cn, ok := w.(http.CloseNotifier); ok { 785 go func(done <-chan struct{}, closed <-chan bool) { 786 select { 787 case <-done: 788 case <-closed: 789 cancel() 790 } 791 }(ctx.Done(), cn.CloseNotify()) 792 } 793 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 794 rctx, err := runtime.AnnotateContext(ctx, mux, req) 795 if err != nil { 796 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 797 return 798 } 799 resp, md, err := request_ApiService_GetDynasty_0(rctx, inboundMarshaler, client, req, pathParams) 800 ctx = runtime.NewServerMetadataContext(ctx, md) 801 if err != nil { 802 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 803 return 804 } 805 806 forward_ApiService_GetDynasty_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 807 808 }) 809 810 mux.Handle("POST", pattern_ApiService_VerifySignature_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 811 ctx, cancel := context.WithCancel(ctx) 812 defer cancel() 813 if cn, ok := w.(http.CloseNotifier); ok { 814 go func(done <-chan struct{}, closed <-chan bool) { 815 select { 816 case <-done: 817 case <-closed: 818 cancel() 819 } 820 }(ctx.Done(), cn.CloseNotify()) 821 } 822 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 823 rctx, err := runtime.AnnotateContext(ctx, mux, req) 824 if err != nil { 825 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 826 return 827 } 828 resp, md, err := request_ApiService_VerifySignature_0(rctx, inboundMarshaler, client, req, pathParams) 829 ctx = runtime.NewServerMetadataContext(ctx, md) 830 if err != nil { 831 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 832 return 833 } 834 835 forward_ApiService_VerifySignature_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 836 837 }) 838 839 return nil 840 } 841 842 var ( 843 pattern_ApiService_GetNebState_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "user", "nebstate"}, "")) 844 845 pattern_ApiService_LatestIrreversibleBlock_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "user", "lib"}, "")) 846 847 pattern_ApiService_GetAccountState_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "user", "accountstate"}, "")) 848 849 pattern_ApiService_Call_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "user", "call"}, "")) 850 851 pattern_ApiService_SendRawTransaction_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "user", "rawtransaction"}, "")) 852 853 pattern_ApiService_GetBlockByHash_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "user", "getBlockByHash"}, "")) 854 855 pattern_ApiService_GetBlockByHeight_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "user", "getBlockByHeight"}, "")) 856 857 pattern_ApiService_GetTransactionReceipt_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "user", "getTransactionReceipt"}, "")) 858 859 pattern_ApiService_GetTransactionByContract_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "user", "getTransactionByContract"}, "")) 860 861 pattern_ApiService_Subscribe_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "user", "subscribe"}, "")) 862 863 pattern_ApiService_GetGasPrice_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "user", "getGasPrice"}, "")) 864 865 pattern_ApiService_EstimateGas_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "user", "estimateGas"}, "")) 866 867 pattern_ApiService_GetEventsByHash_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "user", "getEventsByHash"}, "")) 868 869 pattern_ApiService_GetDynasty_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "user", "dynasty"}, "")) 870 871 pattern_ApiService_VerifySignature_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "user", "verifySignature"}, "")) 872 ) 873 874 var ( 875 forward_ApiService_GetNebState_0 = runtime.ForwardResponseMessage 876 877 forward_ApiService_LatestIrreversibleBlock_0 = runtime.ForwardResponseMessage 878 879 forward_ApiService_GetAccountState_0 = runtime.ForwardResponseMessage 880 881 forward_ApiService_Call_0 = runtime.ForwardResponseMessage 882 883 forward_ApiService_SendRawTransaction_0 = runtime.ForwardResponseMessage 884 885 forward_ApiService_GetBlockByHash_0 = runtime.ForwardResponseMessage 886 887 forward_ApiService_GetBlockByHeight_0 = runtime.ForwardResponseMessage 888 889 forward_ApiService_GetTransactionReceipt_0 = runtime.ForwardResponseMessage 890 891 forward_ApiService_GetTransactionByContract_0 = runtime.ForwardResponseMessage 892 893 forward_ApiService_Subscribe_0 = runtime.ForwardResponseStream 894 895 forward_ApiService_GetGasPrice_0 = runtime.ForwardResponseMessage 896 897 forward_ApiService_EstimateGas_0 = runtime.ForwardResponseMessage 898 899 forward_ApiService_GetEventsByHash_0 = runtime.ForwardResponseMessage 900 901 forward_ApiService_GetDynasty_0 = runtime.ForwardResponseMessage 902 903 forward_ApiService_VerifySignature_0 = runtime.ForwardResponseMessage 904 ) 905 906 // RegisterAdminServiceHandlerFromEndpoint is same as RegisterAdminServiceHandler but 907 // automatically dials to "endpoint" and closes the connection when "ctx" gets done. 908 func RegisterAdminServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) { 909 conn, err := grpc.Dial(endpoint, opts...) 910 if err != nil { 911 return err 912 } 913 defer func() { 914 if err != nil { 915 if cerr := conn.Close(); cerr != nil { 916 grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr) 917 } 918 return 919 } 920 go func() { 921 <-ctx.Done() 922 if cerr := conn.Close(); cerr != nil { 923 grpclog.Printf("Failed to close conn to %s: %v", endpoint, cerr) 924 } 925 }() 926 }() 927 928 return RegisterAdminServiceHandler(ctx, mux, conn) 929 } 930 931 // RegisterAdminServiceHandler registers the http handlers for service AdminService to "mux". 932 // The handlers forward requests to the grpc endpoint over "conn". 933 func RegisterAdminServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error { 934 return RegisterAdminServiceHandlerClient(ctx, mux, NewAdminServiceClient(conn)) 935 } 936 937 // RegisterAdminServiceHandler registers the http handlers for service AdminService to "mux". 938 // The handlers forward requests to the grpc endpoint over the given implementation of "AdminServiceClient". 939 // Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "AdminServiceClient" 940 // doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in 941 // "AdminServiceClient" to call the correct interceptors. 942 func RegisterAdminServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client AdminServiceClient) error { 943 944 mux.Handle("GET", pattern_AdminService_Accounts_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 945 ctx, cancel := context.WithCancel(ctx) 946 defer cancel() 947 if cn, ok := w.(http.CloseNotifier); ok { 948 go func(done <-chan struct{}, closed <-chan bool) { 949 select { 950 case <-done: 951 case <-closed: 952 cancel() 953 } 954 }(ctx.Done(), cn.CloseNotify()) 955 } 956 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 957 rctx, err := runtime.AnnotateContext(ctx, mux, req) 958 if err != nil { 959 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 960 return 961 } 962 resp, md, err := request_AdminService_Accounts_0(rctx, inboundMarshaler, client, req, pathParams) 963 ctx = runtime.NewServerMetadataContext(ctx, md) 964 if err != nil { 965 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 966 return 967 } 968 969 forward_AdminService_Accounts_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 970 971 }) 972 973 mux.Handle("POST", pattern_AdminService_NewAccount_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 974 ctx, cancel := context.WithCancel(ctx) 975 defer cancel() 976 if cn, ok := w.(http.CloseNotifier); ok { 977 go func(done <-chan struct{}, closed <-chan bool) { 978 select { 979 case <-done: 980 case <-closed: 981 cancel() 982 } 983 }(ctx.Done(), cn.CloseNotify()) 984 } 985 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 986 rctx, err := runtime.AnnotateContext(ctx, mux, req) 987 if err != nil { 988 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 989 return 990 } 991 resp, md, err := request_AdminService_NewAccount_0(rctx, inboundMarshaler, client, req, pathParams) 992 ctx = runtime.NewServerMetadataContext(ctx, md) 993 if err != nil { 994 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 995 return 996 } 997 998 forward_AdminService_NewAccount_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 999 1000 }) 1001 1002 mux.Handle("POST", pattern_AdminService_UnlockAccount_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1003 ctx, cancel := context.WithCancel(ctx) 1004 defer cancel() 1005 if cn, ok := w.(http.CloseNotifier); ok { 1006 go func(done <-chan struct{}, closed <-chan bool) { 1007 select { 1008 case <-done: 1009 case <-closed: 1010 cancel() 1011 } 1012 }(ctx.Done(), cn.CloseNotify()) 1013 } 1014 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1015 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1016 if err != nil { 1017 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1018 return 1019 } 1020 resp, md, err := request_AdminService_UnlockAccount_0(rctx, inboundMarshaler, client, req, pathParams) 1021 ctx = runtime.NewServerMetadataContext(ctx, md) 1022 if err != nil { 1023 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1024 return 1025 } 1026 1027 forward_AdminService_UnlockAccount_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1028 1029 }) 1030 1031 mux.Handle("POST", pattern_AdminService_LockAccount_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1032 ctx, cancel := context.WithCancel(ctx) 1033 defer cancel() 1034 if cn, ok := w.(http.CloseNotifier); ok { 1035 go func(done <-chan struct{}, closed <-chan bool) { 1036 select { 1037 case <-done: 1038 case <-closed: 1039 cancel() 1040 } 1041 }(ctx.Done(), cn.CloseNotify()) 1042 } 1043 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1044 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1045 if err != nil { 1046 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1047 return 1048 } 1049 resp, md, err := request_AdminService_LockAccount_0(rctx, inboundMarshaler, client, 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_AdminService_LockAccount_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1057 1058 }) 1059 1060 mux.Handle("POST", pattern_AdminService_SendTransaction_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1061 ctx, cancel := context.WithCancel(ctx) 1062 defer cancel() 1063 if cn, ok := w.(http.CloseNotifier); ok { 1064 go func(done <-chan struct{}, closed <-chan bool) { 1065 select { 1066 case <-done: 1067 case <-closed: 1068 cancel() 1069 } 1070 }(ctx.Done(), cn.CloseNotify()) 1071 } 1072 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1073 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1074 if err != nil { 1075 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1076 return 1077 } 1078 resp, md, err := request_AdminService_SendTransaction_0(rctx, inboundMarshaler, client, req, pathParams) 1079 ctx = runtime.NewServerMetadataContext(ctx, md) 1080 if err != nil { 1081 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1082 return 1083 } 1084 1085 forward_AdminService_SendTransaction_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1086 1087 }) 1088 1089 mux.Handle("POST", pattern_AdminService_SignHash_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1090 ctx, cancel := context.WithCancel(ctx) 1091 defer cancel() 1092 if cn, ok := w.(http.CloseNotifier); ok { 1093 go func(done <-chan struct{}, closed <-chan bool) { 1094 select { 1095 case <-done: 1096 case <-closed: 1097 cancel() 1098 } 1099 }(ctx.Done(), cn.CloseNotify()) 1100 } 1101 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1102 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1103 if err != nil { 1104 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1105 return 1106 } 1107 resp, md, err := request_AdminService_SignHash_0(rctx, inboundMarshaler, client, req, pathParams) 1108 ctx = runtime.NewServerMetadataContext(ctx, md) 1109 if err != nil { 1110 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1111 return 1112 } 1113 1114 forward_AdminService_SignHash_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1115 1116 }) 1117 1118 mux.Handle("POST", pattern_AdminService_GenerateRandomSeed_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1119 ctx, cancel := context.WithCancel(ctx) 1120 defer cancel() 1121 if cn, ok := w.(http.CloseNotifier); ok { 1122 go func(done <-chan struct{}, closed <-chan bool) { 1123 select { 1124 case <-done: 1125 case <-closed: 1126 cancel() 1127 } 1128 }(ctx.Done(), cn.CloseNotify()) 1129 } 1130 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1131 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1132 if err != nil { 1133 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1134 return 1135 } 1136 resp, md, err := request_AdminService_GenerateRandomSeed_0(rctx, inboundMarshaler, client, req, pathParams) 1137 ctx = runtime.NewServerMetadataContext(ctx, md) 1138 if err != nil { 1139 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1140 return 1141 } 1142 1143 forward_AdminService_GenerateRandomSeed_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1144 1145 }) 1146 1147 mux.Handle("POST", pattern_AdminService_SignTransactionWithPassphrase_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1148 ctx, cancel := context.WithCancel(ctx) 1149 defer cancel() 1150 if cn, ok := w.(http.CloseNotifier); ok { 1151 go func(done <-chan struct{}, closed <-chan bool) { 1152 select { 1153 case <-done: 1154 case <-closed: 1155 cancel() 1156 } 1157 }(ctx.Done(), cn.CloseNotify()) 1158 } 1159 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1160 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1161 if err != nil { 1162 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1163 return 1164 } 1165 resp, md, err := request_AdminService_SignTransactionWithPassphrase_0(rctx, inboundMarshaler, client, req, pathParams) 1166 ctx = runtime.NewServerMetadataContext(ctx, md) 1167 if err != nil { 1168 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1169 return 1170 } 1171 1172 forward_AdminService_SignTransactionWithPassphrase_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1173 1174 }) 1175 1176 mux.Handle("POST", pattern_AdminService_SendTransactionWithPassphrase_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1177 ctx, cancel := context.WithCancel(ctx) 1178 defer cancel() 1179 if cn, ok := w.(http.CloseNotifier); ok { 1180 go func(done <-chan struct{}, closed <-chan bool) { 1181 select { 1182 case <-done: 1183 case <-closed: 1184 cancel() 1185 } 1186 }(ctx.Done(), cn.CloseNotify()) 1187 } 1188 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1189 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1190 if err != nil { 1191 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1192 return 1193 } 1194 resp, md, err := request_AdminService_SendTransactionWithPassphrase_0(rctx, inboundMarshaler, client, req, pathParams) 1195 ctx = runtime.NewServerMetadataContext(ctx, md) 1196 if err != nil { 1197 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1198 return 1199 } 1200 1201 forward_AdminService_SendTransactionWithPassphrase_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1202 1203 }) 1204 1205 mux.Handle("POST", pattern_AdminService_StartPprof_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1206 ctx, cancel := context.WithCancel(ctx) 1207 defer cancel() 1208 if cn, ok := w.(http.CloseNotifier); ok { 1209 go func(done <-chan struct{}, closed <-chan bool) { 1210 select { 1211 case <-done: 1212 case <-closed: 1213 cancel() 1214 } 1215 }(ctx.Done(), cn.CloseNotify()) 1216 } 1217 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1218 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1219 if err != nil { 1220 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1221 return 1222 } 1223 resp, md, err := request_AdminService_StartPprof_0(rctx, inboundMarshaler, client, req, pathParams) 1224 ctx = runtime.NewServerMetadataContext(ctx, md) 1225 if err != nil { 1226 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1227 return 1228 } 1229 1230 forward_AdminService_StartPprof_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1231 1232 }) 1233 1234 mux.Handle("GET", pattern_AdminService_GetConfig_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1235 ctx, cancel := context.WithCancel(ctx) 1236 defer cancel() 1237 if cn, ok := w.(http.CloseNotifier); ok { 1238 go func(done <-chan struct{}, closed <-chan bool) { 1239 select { 1240 case <-done: 1241 case <-closed: 1242 cancel() 1243 } 1244 }(ctx.Done(), cn.CloseNotify()) 1245 } 1246 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1247 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1248 if err != nil { 1249 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1250 return 1251 } 1252 resp, md, err := request_AdminService_GetConfig_0(rctx, inboundMarshaler, client, req, pathParams) 1253 ctx = runtime.NewServerMetadataContext(ctx, md) 1254 if err != nil { 1255 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1256 return 1257 } 1258 1259 forward_AdminService_GetConfig_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1260 1261 }) 1262 1263 mux.Handle("GET", pattern_AdminService_NodeInfo_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1264 ctx, cancel := context.WithCancel(ctx) 1265 defer cancel() 1266 if cn, ok := w.(http.CloseNotifier); ok { 1267 go func(done <-chan struct{}, closed <-chan bool) { 1268 select { 1269 case <-done: 1270 case <-closed: 1271 cancel() 1272 } 1273 }(ctx.Done(), cn.CloseNotify()) 1274 } 1275 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1276 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1277 if err != nil { 1278 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1279 return 1280 } 1281 resp, md, err := request_AdminService_NodeInfo_0(rctx, inboundMarshaler, client, req, pathParams) 1282 ctx = runtime.NewServerMetadataContext(ctx, md) 1283 if err != nil { 1284 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1285 return 1286 } 1287 1288 forward_AdminService_NodeInfo_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1289 1290 }) 1291 1292 return nil 1293 } 1294 1295 var ( 1296 pattern_AdminService_Accounts_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "admin", "accounts"}, "")) 1297 1298 pattern_AdminService_NewAccount_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v1", "admin", "account", "new"}, "")) 1299 1300 pattern_AdminService_UnlockAccount_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v1", "admin", "account", "unlock"}, "")) 1301 1302 pattern_AdminService_LockAccount_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v1", "admin", "account", "lock"}, "")) 1303 1304 pattern_AdminService_SendTransaction_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "admin", "transaction"}, "")) 1305 1306 pattern_AdminService_SignHash_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"v1", "admin", "sign", "hash"}, "")) 1307 1308 pattern_AdminService_GenerateRandomSeed_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "admin", "generateRandomSeed"}, "")) 1309 1310 pattern_AdminService_SignTransactionWithPassphrase_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "admin", "sign"}, "")) 1311 1312 pattern_AdminService_SendTransactionWithPassphrase_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "admin", "transactionWithPassphrase"}, "")) 1313 1314 pattern_AdminService_StartPprof_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "admin", "pprof"}, "")) 1315 1316 pattern_AdminService_GetConfig_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "admin", "getConfig"}, "")) 1317 1318 pattern_AdminService_NodeInfo_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "admin", "nodeinfo"}, "")) 1319 ) 1320 1321 var ( 1322 forward_AdminService_Accounts_0 = runtime.ForwardResponseMessage 1323 1324 forward_AdminService_NewAccount_0 = runtime.ForwardResponseMessage 1325 1326 forward_AdminService_UnlockAccount_0 = runtime.ForwardResponseMessage 1327 1328 forward_AdminService_LockAccount_0 = runtime.ForwardResponseMessage 1329 1330 forward_AdminService_SendTransaction_0 = runtime.ForwardResponseMessage 1331 1332 forward_AdminService_SignHash_0 = runtime.ForwardResponseMessage 1333 1334 forward_AdminService_GenerateRandomSeed_0 = runtime.ForwardResponseMessage 1335 1336 forward_AdminService_SignTransactionWithPassphrase_0 = runtime.ForwardResponseMessage 1337 1338 forward_AdminService_SendTransactionWithPassphrase_0 = runtime.ForwardResponseMessage 1339 1340 forward_AdminService_StartPprof_0 = runtime.ForwardResponseMessage 1341 1342 forward_AdminService_GetConfig_0 = runtime.ForwardResponseMessage 1343 1344 forward_AdminService_NodeInfo_0 = runtime.ForwardResponseMessage 1345 )