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  )