tech.figure.block.api.proto.BlockServiceOuterClassGrpcKt.kt Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of api-proto Show documentation
gRPC client code to interact with Figures off chain Provenance data
The newest version!
package tech.figure.block.api.proto

import io.grpc.CallOptions
import io.grpc.CallOptions.DEFAULT
import io.grpc.Channel
import io.grpc.Metadata
import io.grpc.MethodDescriptor
import io.grpc.ServerServiceDefinition
import io.grpc.ServerServiceDefinition.builder
import io.grpc.ServiceDescriptor
import io.grpc.Status
import io.grpc.Status.UNIMPLEMENTED
import io.grpc.StatusException
import io.grpc.kotlin.AbstractCoroutineServerImpl
import io.grpc.kotlin.AbstractCoroutineStub
import io.grpc.kotlin.ClientCalls
import io.grpc.kotlin.ClientCalls.serverStreamingRpc
import io.grpc.kotlin.ClientCalls.unaryRpc
import io.grpc.kotlin.ServerCalls
import io.grpc.kotlin.ServerCalls.serverStreamingServerMethodDefinition
import io.grpc.kotlin.ServerCalls.unaryServerMethodDefinition
import io.grpc.kotlin.StubFor
import kotlin.String
import kotlin.coroutines.CoroutineContext
import kotlin.coroutines.EmptyCoroutineContext
import kotlin.jvm.JvmOverloads
import kotlin.jvm.JvmStatic
import kotlinx.coroutines.flow.Flow
import tech.figure.block.api.proto.BlockServiceGrpc.getServiceDescriptor

/**
 * Holder for Kotlin coroutine-based client and server APIs for api.BlockService.
 */
public object BlockServiceGrpcKt {
  public const val SERVICE_NAME: String = BlockServiceGrpc.SERVICE_NAME

  @JvmStatic
  public val serviceDescriptor: ServiceDescriptor
    get() = BlockServiceGrpc.getServiceDescriptor()

  public val blockStreamMethod:
      MethodDescriptor
    @JvmStatic
    get() = BlockServiceGrpc.getBlockStreamMethod()

  public val eventsMethod:
      MethodDescriptor
    @JvmStatic
    get() = BlockServiceGrpc.getEventsMethod()

  public val statusMethod:
      MethodDescriptor
    @JvmStatic
    get() = BlockServiceGrpc.getStatusMethod()

  public val getAddressTransactionsMethod:
      MethodDescriptor
    @JvmStatic
    get() = BlockServiceGrpc.getGetAddressTransactionsMethod()

  public val getScopeTransactionsMethod:
      MethodDescriptor
    @JvmStatic
    get() = BlockServiceGrpc.getGetScopeTransactionsMethod()

  public val getMarkerTransactionsMethod:
      MethodDescriptor
    @JvmStatic
    get() = BlockServiceGrpc.getGetMarkerTransactionsMethod()

  public val getGroupTransactionsMethod:
      MethodDescriptor
    @JvmStatic
    get() = BlockServiceGrpc.getGetGroupTransactionsMethod()

  public val getScopesMethod:
      MethodDescriptor
    @JvmStatic
    get() = BlockServiceGrpc.getGetScopesMethod()

  public val streamLatestScopeStateMethod:
      MethodDescriptor
    @JvmStatic
    get() = BlockServiceGrpc.getStreamLatestScopeStateMethod()

  public val getContractTransactionsMethod:
      MethodDescriptor
    @JvmStatic
    get() = BlockServiceGrpc.getGetContractTransactionsMethod()

  public val getFeeInfoMethod:
      MethodDescriptor
    @JvmStatic
    get() = BlockServiceGrpc.getGetFeeInfoMethod()

  public val getBlockByHeightMethod:
      MethodDescriptor
    @JvmStatic
    get() = BlockServiceGrpc.getGetBlockByHeightMethod()

  public val getBlocksByHeightMethod:
      MethodDescriptor
    @JvmStatic
    get() = BlockServiceGrpc.getGetBlocksByHeightMethod()

  public val getTransactionByHashMethod:
      MethodDescriptor
    @JvmStatic
    get() = BlockServiceGrpc.getGetTransactionByHashMethod()

  /**
   * A stub for issuing RPCs to a(n) api.BlockService service as suspending coroutines.
   */
  @StubFor(BlockServiceGrpc::class)
  public class BlockServiceCoroutineStub @JvmOverloads constructor(
    channel: Channel,
    callOptions: CallOptions = DEFAULT,
  ) : AbstractCoroutineStub(channel, callOptions) {
    public override fun build(channel: Channel, callOptions: CallOptions): BlockServiceCoroutineStub
        = BlockServiceCoroutineStub(channel, callOptions)

    /**
     * Returns a [Flow] that, when collected, executes this RPC and emits responses from the
     * server as they arrive.  That flow finishes normally if the server closes its response with
     * [`Status.OK`][Status], and fails by throwing a [StatusException] otherwise.  If
     * collecting the flow downstream fails exceptionally (including via cancellation), the RPC
     * is cancelled with that exception as a cause.
     *
     * @param request The request message to send to the server.
     *
     * @param headers Metadata to attach to the request.  Most users will not need this.
     *
     * @return A flow that, when collected, emits the responses from the server.
     */
    public fun blockStream(request: BlockServiceOuterClass.BlockStreamRequest, headers: Metadata =
        Metadata()): Flow = serverStreamingRpc(
      channel,
      BlockServiceGrpc.getBlockStreamMethod(),
      request,
      callOptions,
      headers
    )

    /**
     * Returns a [Flow] that, when collected, executes this RPC and emits responses from the
     * server as they arrive.  That flow finishes normally if the server closes its response with
     * [`Status.OK`][Status], and fails by throwing a [StatusException] otherwise.  If
     * collecting the flow downstream fails exceptionally (including via cancellation), the RPC
     * is cancelled with that exception as a cause.
     *
     * @param request The request message to send to the server.
     *
     * @param headers Metadata to attach to the request.  Most users will not need this.
     *
     * @return A flow that, when collected, emits the responses from the server.
     */
    public fun events(request: BlockServiceOuterClass.EventRequest, headers: Metadata = Metadata()):
        Flow = serverStreamingRpc(
      channel,
      BlockServiceGrpc.getEventsMethod(),
      request,
      callOptions,
      headers
    )

    /**
     * Executes this RPC and returns the response message, suspending until the RPC completes
     * with [`Status.OK`][Status].  If the RPC completes with another status, a corresponding
     * [StatusException] is thrown.  If this coroutine is cancelled, the RPC is also cancelled
     * with the corresponding exception as a cause.
     *
     * @param request The request message to send to the server.
     *
     * @param headers Metadata to attach to the request.  Most users will not need this.
     *
     * @return The single response from the server.
     */
    public suspend fun status(request: BlockServiceOuterClass.StatusRequest, headers: Metadata =
        Metadata()): BlockServiceOuterClass.StatusResult = unaryRpc(
      channel,
      BlockServiceGrpc.getStatusMethod(),
      request,
      callOptions,
      headers
    )

    /**
     * Executes this RPC and returns the response message, suspending until the RPC completes
     * with [`Status.OK`][Status].  If the RPC completes with another status, a corresponding
     * [StatusException] is thrown.  If this coroutine is cancelled, the RPC is also cancelled
     * with the corresponding exception as a cause.
     *
     * @param request The request message to send to the server.
     *
     * @param headers Metadata to attach to the request.  Most users will not need this.
     *
     * @return The single response from the server.
     */
    public suspend fun getAddressTransactions(request: BlockServiceOuterClass.AddressRequest,
        headers: Metadata = Metadata()): BlockServiceOuterClass.TransactionsResult = unaryRpc(
      channel,
      BlockServiceGrpc.getGetAddressTransactionsMethod(),
      request,
      callOptions,
      headers
    )

    /**
     * Executes this RPC and returns the response message, suspending until the RPC completes
     * with [`Status.OK`][Status].  If the RPC completes with another status, a corresponding
     * [StatusException] is thrown.  If this coroutine is cancelled, the RPC is also cancelled
     * with the corresponding exception as a cause.
     *
     * @param request The request message to send to the server.
     *
     * @param headers Metadata to attach to the request.  Most users will not need this.
     *
     * @return The single response from the server.
     */
    public suspend fun getScopeTransactions(request: BlockServiceOuterClass.AddressRequest,
        headers: Metadata = Metadata()): BlockServiceOuterClass.TransactionsResult = unaryRpc(
      channel,
      BlockServiceGrpc.getGetScopeTransactionsMethod(),
      request,
      callOptions,
      headers
    )

    /**
     * Executes this RPC and returns the response message, suspending until the RPC completes
     * with [`Status.OK`][Status].  If the RPC completes with another status, a corresponding
     * [StatusException] is thrown.  If this coroutine is cancelled, the RPC is also cancelled
     * with the corresponding exception as a cause.
     *
     * @param request The request message to send to the server.
     *
     * @param headers Metadata to attach to the request.  Most users will not need this.
     *
     * @return The single response from the server.
     */
    public suspend fun getMarkerTransactions(request: BlockServiceOuterClass.AddressRequest,
        headers: Metadata = Metadata()): BlockServiceOuterClass.TransactionsResult = unaryRpc(
      channel,
      BlockServiceGrpc.getGetMarkerTransactionsMethod(),
      request,
      callOptions,
      headers
    )

    /**
     * Executes this RPC and returns the response message, suspending until the RPC completes
     * with [`Status.OK`][Status].  If the RPC completes with another status, a corresponding
     * [StatusException] is thrown.  If this coroutine is cancelled, the RPC is also cancelled
     * with the corresponding exception as a cause.
     *
     * @param request The request message to send to the server.
     *
     * @param headers Metadata to attach to the request.  Most users will not need this.
     *
     * @return The single response from the server.
     */
    public suspend fun getGroupTransactions(request: BlockServiceOuterClass.AddressRequest,
        headers: Metadata = Metadata()): BlockServiceOuterClass.TransactionsResult = unaryRpc(
      channel,
      BlockServiceGrpc.getGetGroupTransactionsMethod(),
      request,
      callOptions,
      headers
    )

    /**
     * Executes this RPC and returns the response message, suspending until the RPC completes
     * with [`Status.OK`][Status].  If the RPC completes with another status, a corresponding
     * [StatusException] is thrown.  If this coroutine is cancelled, the RPC is also cancelled
     * with the corresponding exception as a cause.
     *
     * @param request The request message to send to the server.
     *
     * @param headers Metadata to attach to the request.  Most users will not need this.
     *
     * @return The single response from the server.
     */
    public suspend fun getScopes(request: BlockServiceOuterClass.ScopeStateRequest,
        headers: Metadata = Metadata()): BlockServiceOuterClass.ScopeStatePagedResponse = unaryRpc(
      channel,
      BlockServiceGrpc.getGetScopesMethod(),
      request,
      callOptions,
      headers
    )

    /**
     * Returns a [Flow] that, when collected, executes this RPC and emits responses from the
     * server as they arrive.  That flow finishes normally if the server closes its response with
     * [`Status.OK`][Status], and fails by throwing a [StatusException] otherwise.  If
     * collecting the flow downstream fails exceptionally (including via cancellation), the RPC
     * is cancelled with that exception as a cause.
     *
     * @param request The request message to send to the server.
     *
     * @param headers Metadata to attach to the request.  Most users will not need this.
     *
     * @return A flow that, when collected, emits the responses from the server.
     */
    public fun streamLatestScopeState(request: BlockServiceOuterClass.LatestScopeStreamRequest,
        headers: Metadata = Metadata()): Flow =
        serverStreamingRpc(
      channel,
      BlockServiceGrpc.getStreamLatestScopeStateMethod(),
      request,
      callOptions,
      headers
    )

    /**
     * Executes this RPC and returns the response message, suspending until the RPC completes
     * with [`Status.OK`][Status].  If the RPC completes with another status, a corresponding
     * [StatusException] is thrown.  If this coroutine is cancelled, the RPC is also cancelled
     * with the corresponding exception as a cause.
     *
     * @param request The request message to send to the server.
     *
     * @param headers Metadata to attach to the request.  Most users will not need this.
     *
     * @return The single response from the server.
     */
    public suspend fun getContractTransactions(request: BlockServiceOuterClass.AddressRequest,
        headers: Metadata = Metadata()): BlockServiceOuterClass.TransactionsResult = unaryRpc(
      channel,
      BlockServiceGrpc.getGetContractTransactionsMethod(),
      request,
      callOptions,
      headers
    )

    /**
     * Executes this RPC and returns the response message, suspending until the RPC completes
     * with [`Status.OK`][Status].  If the RPC completes with another status, a corresponding
     * [StatusException] is thrown.  If this coroutine is cancelled, the RPC is also cancelled
     * with the corresponding exception as a cause.
     *
     * @param request The request message to send to the server.
     *
     * @param headers Metadata to attach to the request.  Most users will not need this.
     *
     * @return The single response from the server.
     */
    public suspend fun getFeeInfo(request: BlockServiceOuterClass.GetFeeRequest, headers: Metadata =
        Metadata()): BlockServiceOuterClass.FeeResult = unaryRpc(
      channel,
      BlockServiceGrpc.getGetFeeInfoMethod(),
      request,
      callOptions,
      headers
    )

    /**
     * Executes this RPC and returns the response message, suspending until the RPC completes
     * with [`Status.OK`][Status].  If the RPC completes with another status, a corresponding
     * [StatusException] is thrown.  If this coroutine is cancelled, the RPC is also cancelled
     * with the corresponding exception as a cause.
     *
     * @param request The request message to send to the server.
     *
     * @param headers Metadata to attach to the request.  Most users will not need this.
     *
     * @return The single response from the server.
     */
    public suspend fun getBlockByHeight(request: BlockServiceOuterClass.GetBlockRequest,
        headers: Metadata = Metadata()): BlockServiceOuterClass.BlockResult = unaryRpc(
      channel,
      BlockServiceGrpc.getGetBlockByHeightMethod(),
      request,
      callOptions,
      headers
    )

    /**
     * Executes this RPC and returns the response message, suspending until the RPC completes
     * with [`Status.OK`][Status].  If the RPC completes with another status, a corresponding
     * [StatusException] is thrown.  If this coroutine is cancelled, the RPC is also cancelled
     * with the corresponding exception as a cause.
     *
     * @param request The request message to send to the server.
     *
     * @param headers Metadata to attach to the request.  Most users will not need this.
     *
     * @return The single response from the server.
     */
    public suspend fun getBlocksByHeight(request: BlockServiceOuterClass.GetBlocksRequest,
        headers: Metadata = Metadata()): BlockServiceOuterClass.BlocksResult = unaryRpc(
      channel,
      BlockServiceGrpc.getGetBlocksByHeightMethod(),
      request,
      callOptions,
      headers
    )

    /**
     * Executes this RPC and returns the response message, suspending until the RPC completes
     * with [`Status.OK`][Status].  If the RPC completes with another status, a corresponding
     * [StatusException] is thrown.  If this coroutine is cancelled, the RPC is also cancelled
     * with the corresponding exception as a cause.
     *
     * @param request The request message to send to the server.
     *
     * @param headers Metadata to attach to the request.  Most users will not need this.
     *
     * @return The single response from the server.
     */
    public suspend fun getTransactionByHash(request: BlockServiceOuterClass.GetTransactionRequest,
        headers: Metadata = Metadata()): BlockOuterClass.Transaction = unaryRpc(
      channel,
      BlockServiceGrpc.getGetTransactionByHashMethod(),
      request,
      callOptions,
      headers
    )
  }

  /**
   * Skeletal implementation of the api.BlockService service based on Kotlin coroutines.
   */
  public abstract class BlockServiceCoroutineImplBase(
    coroutineContext: CoroutineContext = EmptyCoroutineContext,
  ) : AbstractCoroutineServerImpl(coroutineContext) {
    /**
     * Returns a [Flow] of responses to an RPC for api.BlockService.BlockStream.
     *
     * If creating or collecting the returned flow fails with a [StatusException], the RPC
     * will fail with the corresponding [Status].  If it fails with a
     * [java.util.concurrent.CancellationException], the RPC will fail with status
     * `Status.CANCELLED`.  If creating
     * or collecting the returned flow fails for any other reason, the RPC will fail with
     * `Status.UNKNOWN` with the exception as a cause.
     *
     * @param request The request from the client.
     */
    public open fun blockStream(request: BlockServiceOuterClass.BlockStreamRequest):
        Flow = throw
        StatusException(UNIMPLEMENTED.withDescription("Method api.BlockService.BlockStream is unimplemented"))

    /**
     * Returns a [Flow] of responses to an RPC for api.BlockService.Events.
     *
     * If creating or collecting the returned flow fails with a [StatusException], the RPC
     * will fail with the corresponding [Status].  If it fails with a
     * [java.util.concurrent.CancellationException], the RPC will fail with status
     * `Status.CANCELLED`.  If creating
     * or collecting the returned flow fails for any other reason, the RPC will fail with
     * `Status.UNKNOWN` with the exception as a cause.
     *
     * @param request The request from the client.
     */
    public open fun events(request: BlockServiceOuterClass.EventRequest):
        Flow = throw
        StatusException(UNIMPLEMENTED.withDescription("Method api.BlockService.Events is unimplemented"))

    /**
     * Returns the response to an RPC for api.BlockService.Status.
     *
     * If this method fails with a [StatusException], the RPC will fail with the corresponding
     * [Status].  If this method fails with a [java.util.concurrent.CancellationException], the RPC
     * will fail
     * with status `Status.CANCELLED`.  If this method fails for any other reason, the RPC will
     * fail with `Status.UNKNOWN` with the exception as a cause.
     *
     * @param request The request from the client.
     */
    public open suspend fun status(request: BlockServiceOuterClass.StatusRequest):
        BlockServiceOuterClass.StatusResult = throw
        StatusException(UNIMPLEMENTED.withDescription("Method api.BlockService.Status is unimplemented"))

    /**
     * Returns the response to an RPC for api.BlockService.GetAddressTransactions.
     *
     * If this method fails with a [StatusException], the RPC will fail with the corresponding
     * [Status].  If this method fails with a [java.util.concurrent.CancellationException], the RPC
     * will fail
     * with status `Status.CANCELLED`.  If this method fails for any other reason, the RPC will
     * fail with `Status.UNKNOWN` with the exception as a cause.
     *
     * @param request The request from the client.
     */
    public open suspend fun getAddressTransactions(request: BlockServiceOuterClass.AddressRequest):
        BlockServiceOuterClass.TransactionsResult = throw
        StatusException(UNIMPLEMENTED.withDescription("Method api.BlockService.GetAddressTransactions is unimplemented"))

    /**
     * Returns the response to an RPC for api.BlockService.GetScopeTransactions.
     *
     * If this method fails with a [StatusException], the RPC will fail with the corresponding
     * [Status].  If this method fails with a [java.util.concurrent.CancellationException], the RPC
     * will fail
     * with status `Status.CANCELLED`.  If this method fails for any other reason, the RPC will
     * fail with `Status.UNKNOWN` with the exception as a cause.
     *
     * @param request The request from the client.
     */
    public open suspend fun getScopeTransactions(request: BlockServiceOuterClass.AddressRequest):
        BlockServiceOuterClass.TransactionsResult = throw
        StatusException(UNIMPLEMENTED.withDescription("Method api.BlockService.GetScopeTransactions is unimplemented"))

    /**
     * Returns the response to an RPC for api.BlockService.GetMarkerTransactions.
     *
     * If this method fails with a [StatusException], the RPC will fail with the corresponding
     * [Status].  If this method fails with a [java.util.concurrent.CancellationException], the RPC
     * will fail
     * with status `Status.CANCELLED`.  If this method fails for any other reason, the RPC will
     * fail with `Status.UNKNOWN` with the exception as a cause.
     *
     * @param request The request from the client.
     */
    public open suspend fun getMarkerTransactions(request: BlockServiceOuterClass.AddressRequest):
        BlockServiceOuterClass.TransactionsResult = throw
        StatusException(UNIMPLEMENTED.withDescription("Method api.BlockService.GetMarkerTransactions is unimplemented"))

    /**
     * Returns the response to an RPC for api.BlockService.GetGroupTransactions.
     *
     * If this method fails with a [StatusException], the RPC will fail with the corresponding
     * [Status].  If this method fails with a [java.util.concurrent.CancellationException], the RPC
     * will fail
     * with status `Status.CANCELLED`.  If this method fails for any other reason, the RPC will
     * fail with `Status.UNKNOWN` with the exception as a cause.
     *
     * @param request The request from the client.
     */
    public open suspend fun getGroupTransactions(request: BlockServiceOuterClass.AddressRequest):
        BlockServiceOuterClass.TransactionsResult = throw
        StatusException(UNIMPLEMENTED.withDescription("Method api.BlockService.GetGroupTransactions is unimplemented"))

    /**
     * Returns the response to an RPC for api.BlockService.GetScopes.
     *
     * If this method fails with a [StatusException], the RPC will fail with the corresponding
     * [Status].  If this method fails with a [java.util.concurrent.CancellationException], the RPC
     * will fail
     * with status `Status.CANCELLED`.  If this method fails for any other reason, the RPC will
     * fail with `Status.UNKNOWN` with the exception as a cause.
     *
     * @param request The request from the client.
     */
    public open suspend fun getScopes(request: BlockServiceOuterClass.ScopeStateRequest):
        BlockServiceOuterClass.ScopeStatePagedResponse = throw
        StatusException(UNIMPLEMENTED.withDescription("Method api.BlockService.GetScopes is unimplemented"))

    /**
     * Returns a [Flow] of responses to an RPC for api.BlockService.StreamLatestScopeState.
     *
     * If creating or collecting the returned flow fails with a [StatusException], the RPC
     * will fail with the corresponding [Status].  If it fails with a
     * [java.util.concurrent.CancellationException], the RPC will fail with status
     * `Status.CANCELLED`.  If creating
     * or collecting the returned flow fails for any other reason, the RPC will fail with
     * `Status.UNKNOWN` with the exception as a cause.
     *
     * @param request The request from the client.
     */
    public open
        fun streamLatestScopeState(request: BlockServiceOuterClass.LatestScopeStreamRequest):
        Flow = throw
        StatusException(UNIMPLEMENTED.withDescription("Method api.BlockService.StreamLatestScopeState is unimplemented"))

    /**
     * Returns the response to an RPC for api.BlockService.GetContractTransactions.
     *
     * If this method fails with a [StatusException], the RPC will fail with the corresponding
     * [Status].  If this method fails with a [java.util.concurrent.CancellationException], the RPC
     * will fail
     * with status `Status.CANCELLED`.  If this method fails for any other reason, the RPC will
     * fail with `Status.UNKNOWN` with the exception as a cause.
     *
     * @param request The request from the client.
     */
    public open suspend fun getContractTransactions(request: BlockServiceOuterClass.AddressRequest):
        BlockServiceOuterClass.TransactionsResult = throw
        StatusException(UNIMPLEMENTED.withDescription("Method api.BlockService.GetContractTransactions is unimplemented"))

    /**
     * Returns the response to an RPC for api.BlockService.GetFeeInfo.
     *
     * If this method fails with a [StatusException], the RPC will fail with the corresponding
     * [Status].  If this method fails with a [java.util.concurrent.CancellationException], the RPC
     * will fail
     * with status `Status.CANCELLED`.  If this method fails for any other reason, the RPC will
     * fail with `Status.UNKNOWN` with the exception as a cause.
     *
     * @param request The request from the client.
     */
    public open suspend fun getFeeInfo(request: BlockServiceOuterClass.GetFeeRequest):
        BlockServiceOuterClass.FeeResult = throw
        StatusException(UNIMPLEMENTED.withDescription("Method api.BlockService.GetFeeInfo is unimplemented"))

    /**
     * Returns the response to an RPC for api.BlockService.GetBlockByHeight.
     *
     * If this method fails with a [StatusException], the RPC will fail with the corresponding
     * [Status].  If this method fails with a [java.util.concurrent.CancellationException], the RPC
     * will fail
     * with status `Status.CANCELLED`.  If this method fails for any other reason, the RPC will
     * fail with `Status.UNKNOWN` with the exception as a cause.
     *
     * @param request The request from the client.
     */
    public open suspend fun getBlockByHeight(request: BlockServiceOuterClass.GetBlockRequest):
        BlockServiceOuterClass.BlockResult = throw
        StatusException(UNIMPLEMENTED.withDescription("Method api.BlockService.GetBlockByHeight is unimplemented"))

    /**
     * Returns the response to an RPC for api.BlockService.GetBlocksByHeight.
     *
     * If this method fails with a [StatusException], the RPC will fail with the corresponding
     * [Status].  If this method fails with a [java.util.concurrent.CancellationException], the RPC
     * will fail
     * with status `Status.CANCELLED`.  If this method fails for any other reason, the RPC will
     * fail with `Status.UNKNOWN` with the exception as a cause.
     *
     * @param request The request from the client.
     */
    public open suspend fun getBlocksByHeight(request: BlockServiceOuterClass.GetBlocksRequest):
        BlockServiceOuterClass.BlocksResult = throw
        StatusException(UNIMPLEMENTED.withDescription("Method api.BlockService.GetBlocksByHeight is unimplemented"))

    /**
     * Returns the response to an RPC for api.BlockService.GetTransactionByHash.
     *
     * If this method fails with a [StatusException], the RPC will fail with the corresponding
     * [Status].  If this method fails with a [java.util.concurrent.CancellationException], the RPC
     * will fail
     * with status `Status.CANCELLED`.  If this method fails for any other reason, the RPC will
     * fail with `Status.UNKNOWN` with the exception as a cause.
     *
     * @param request The request from the client.
     */
    public open suspend
        fun getTransactionByHash(request: BlockServiceOuterClass.GetTransactionRequest):
        BlockOuterClass.Transaction = throw
        StatusException(UNIMPLEMENTED.withDescription("Method api.BlockService.GetTransactionByHash is unimplemented"))

    public final override fun bindService(): ServerServiceDefinition =
        builder(getServiceDescriptor())
      .addMethod(serverStreamingServerMethodDefinition(
      context = this.context,
      descriptor = BlockServiceGrpc.getBlockStreamMethod(),
      implementation = ::blockStream
    ))
      .addMethod(serverStreamingServerMethodDefinition(
      context = this.context,
      descriptor = BlockServiceGrpc.getEventsMethod(),
      implementation = ::events
    ))
      .addMethod(unaryServerMethodDefinition(
      context = this.context,
      descriptor = BlockServiceGrpc.getStatusMethod(),
      implementation = ::status
    ))
      .addMethod(unaryServerMethodDefinition(
      context = this.context,
      descriptor = BlockServiceGrpc.getGetAddressTransactionsMethod(),
      implementation = ::getAddressTransactions
    ))
      .addMethod(unaryServerMethodDefinition(
      context = this.context,
      descriptor = BlockServiceGrpc.getGetScopeTransactionsMethod(),
      implementation = ::getScopeTransactions
    ))
      .addMethod(unaryServerMethodDefinition(
      context = this.context,
      descriptor = BlockServiceGrpc.getGetMarkerTransactionsMethod(),
      implementation = ::getMarkerTransactions
    ))
      .addMethod(unaryServerMethodDefinition(
      context = this.context,
      descriptor = BlockServiceGrpc.getGetGroupTransactionsMethod(),
      implementation = ::getGroupTransactions
    ))
      .addMethod(unaryServerMethodDefinition(
      context = this.context,
      descriptor = BlockServiceGrpc.getGetScopesMethod(),
      implementation = ::getScopes
    ))
      .addMethod(serverStreamingServerMethodDefinition(
      context = this.context,
      descriptor = BlockServiceGrpc.getStreamLatestScopeStateMethod(),
      implementation = ::streamLatestScopeState
    ))
      .addMethod(unaryServerMethodDefinition(
      context = this.context,
      descriptor = BlockServiceGrpc.getGetContractTransactionsMethod(),
      implementation = ::getContractTransactions
    ))
      .addMethod(unaryServerMethodDefinition(
      context = this.context,
      descriptor = BlockServiceGrpc.getGetFeeInfoMethod(),
      implementation = ::getFeeInfo
    ))
      .addMethod(unaryServerMethodDefinition(
      context = this.context,
      descriptor = BlockServiceGrpc.getGetBlockByHeightMethod(),
      implementation = ::getBlockByHeight
    ))
      .addMethod(unaryServerMethodDefinition(
      context = this.context,
      descriptor = BlockServiceGrpc.getGetBlocksByHeightMethod(),
      implementation = ::getBlocksByHeight
    ))
      .addMethod(unaryServerMethodDefinition(
      context = this.context,
      descriptor = BlockServiceGrpc.getGetTransactionByHashMethod(),
      implementation = ::getTransactionByHash
    )).build()
  }
}