syntax = "proto3";

package flow.access;

option go_package = "github.com/onflow/flow/protobuf/go/flow/access";
option java_package = "org.onflow.protobuf.access";

import "flow/entities/account.proto";
import "flow/entities/block_header.proto";
import "flow/entities/block.proto";
import "flow/entities/collection.proto";
import "flow/entities/event.proto";
import "flow/entities/execution_result.proto";
import "flow/entities/execution_state.proto";
import "flow/entities/metadata.proto";
import "flow/entities/node_version_info.proto";
import "flow/entities/transaction.proto";
import "google/protobuf/timestamp.proto";

// AccessAPI is the public-facing API provided by access nodes.
service AccessAPI {
  // Ping is used to check if the access node is alive and healthy.
  rpc Ping(PingRequest) returns (PingResponse);

  // GetNodeVersionInfo return node version information, such as semver,
  // commit, sporkID and protocol version.
  rpc GetNodeVersionInfo(GetNodeVersionInfoRequest)
      returns (GetNodeVersionInfoResponse);

  // Block Headers

  // GetLatestBlockHeader gets the latest sealed or unsealed block header.
  rpc GetLatestBlockHeader(GetLatestBlockHeaderRequest)
      returns (BlockHeaderResponse);
  // GetBlockHeaderByID gets a block header by ID.
  rpc GetBlockHeaderByID(GetBlockHeaderByIDRequest)
      returns (BlockHeaderResponse);
  // GetBlockHeaderByHeight gets a block header by height.
  rpc GetBlockHeaderByHeight(GetBlockHeaderByHeightRequest)
      returns (BlockHeaderResponse);

  // Blocks

  // GetLatestBlock gets the full payload of the latest sealed or unsealed
  // block.
  rpc GetLatestBlock(GetLatestBlockRequest) returns (BlockResponse);
  // GetBlockByID gets a full block by ID.
  rpc GetBlockByID(GetBlockByIDRequest) returns (BlockResponse);
  // GetBlockByHeight gets a full block by height.
  rpc GetBlockByHeight(GetBlockByHeightRequest) returns (BlockResponse);

  // Collections

  // GetCollectionByID gets a collection by ID.
  rpc GetCollectionByID(GetCollectionByIDRequest) returns (CollectionResponse);
  // GetFullCollectionByID gets a collection by ID.
  rpc GetFullCollectionByID(GetFullCollectionByIDRequest)
      returns (FullCollectionResponse);

  // Transactions

  // SendTransaction submits a transaction to the network.
  rpc SendTransaction(SendTransactionRequest) returns (SendTransactionResponse);
  // GetTransaction gets a transaction by ID.
  rpc GetTransaction(GetTransactionRequest) returns (TransactionResponse);
  // GetTransactionResult gets the result of a transaction.
  rpc GetTransactionResult(GetTransactionRequest)
      returns (TransactionResultResponse);
  // GetTransactionResultByIndex gets the result of a transaction at a specified
  // block and index
  rpc GetTransactionResultByIndex(GetTransactionByIndexRequest)
      returns (TransactionResultResponse);
  // GetTransactionResultsByBlockID gets all the transaction results for a
  // specified block
  rpc GetTransactionResultsByBlockID(GetTransactionsByBlockIDRequest)
      returns (TransactionResultsResponse);
  // GetTransactionsByBlockID gets all the transactions for a specified block
  rpc GetTransactionsByBlockID(GetTransactionsByBlockIDRequest)
      returns (TransactionsResponse);
  // GetSystemTransaction gets a system transaction
  rpc GetSystemTransaction(GetSystemTransactionRequest)
      returns (TransactionResponse);
  // GetSystemTransactionResult gets a system transaction result for a
  // specified block
  rpc GetSystemTransactionResult(GetSystemTransactionResultRequest)
      returns (TransactionResultResponse);

  // GetScheduledTransaction gets a scheduled transaction body for a given callback ID
  rpc GetScheduledTransaction(GetScheduledTransactionRequest)
      returns (TransactionResponse);

  // GetScheduledTransactionResult gets a scheduled transaction result for a given callback ID
  rpc GetScheduledTransactionResult(GetScheduledTransactionResultRequest)
      returns (TransactionResultResponse);

  // Accounts

  // GetAccount is an alias for GetAccountAtLatestBlock.
  //
  // Warning: this function is deprecated. It behaves identically to
  // GetAccountAtLatestBlock and will be removed in a future version.
  rpc GetAccount(GetAccountRequest) returns (GetAccountResponse);
  // GetAccountAtLatestBlock gets an account by address from the latest sealed
  // execution state.
  rpc GetAccountAtLatestBlock(GetAccountAtLatestBlockRequest)
      returns (AccountResponse);
  // GetAccountAtBlockHeight gets an account by address at the given block
  // height
  rpc GetAccountAtBlockHeight(GetAccountAtBlockHeightRequest)
      returns (AccountResponse);

  // GetAccountBalanceAtLatestBlock gets an account balance by address from the
  // latest sealed execution state.
  rpc GetAccountBalanceAtLatestBlock(GetAccountBalanceAtLatestBlockRequest)
      returns (AccountBalanceResponse);
  // GetAccountBalanceAtBlockHeight gets an account balance by address at the
  // given block height
  rpc GetAccountBalanceAtBlockHeight(GetAccountBalanceAtBlockHeightRequest)
      returns (AccountBalanceResponse);

  // GetAccountKeysAtLatestBlock gets an account public keys by address from the
  // latest sealed execution state.
  rpc GetAccountKeysAtLatestBlock(GetAccountKeysAtLatestBlockRequest)
      returns (AccountKeysResponse);
  // GetAccountKeysAtBlockHeight gets an account public keys by address at the
  // given block height
  rpc GetAccountKeysAtBlockHeight(GetAccountKeysAtBlockHeightRequest)
      returns (AccountKeysResponse);

  // GetAccountKeysAtLatestBlock gets an account public key by address and key
  // index from the latest sealed execution state.
  rpc GetAccountKeyAtLatestBlock(GetAccountKeyAtLatestBlockRequest)
      returns (AccountKeyResponse);
  // GetAccountKeysAtBlockHeight gets an account public key by address and key
  // index at the given block height
  rpc GetAccountKeyAtBlockHeight(GetAccountKeyAtBlockHeightRequest)
      returns (AccountKeyResponse);

  // Scripts

  // ExecuteScriptAtLatestBlock executes a read-only Cadence script against the
  // latest sealed execution state.
  rpc ExecuteScriptAtLatestBlock(ExecuteScriptAtLatestBlockRequest)
      returns (ExecuteScriptResponse);
  // ExecuteScriptAtBlockID executes a ready-only Cadence script against the
  // execution state at the block with the given ID.
  rpc ExecuteScriptAtBlockID(ExecuteScriptAtBlockIDRequest)
      returns (ExecuteScriptResponse);
  // ExecuteScriptAtBlockHeight executes a ready-only Cadence script against the
  // execution state at the given block height.
  rpc ExecuteScriptAtBlockHeight(ExecuteScriptAtBlockHeightRequest)
      returns (ExecuteScriptResponse);

  // Events

  // GetEventsForHeightRange retrieves events emitted within the specified block
  // range.
  rpc GetEventsForHeightRange(GetEventsForHeightRangeRequest)
      returns (EventsResponse);

  // GetEventsForBlockIDs retrieves events for the specified block IDs and event
  // type.
  rpc GetEventsForBlockIDs(GetEventsForBlockIDsRequest)
      returns (EventsResponse);

  // NetworkParameters

  // GetNetworkParameters retrieves the Flow network details
  rpc GetNetworkParameters(GetNetworkParametersRequest)
      returns (GetNetworkParametersResponse);

  // ProtocolState

  // GetLatestProtocolStateSnapshot retrieves the latest sealed protocol state
  // snapshot. Used by Flow nodes joining the network to bootstrap a
  // space-efficient local state.
  rpc GetLatestProtocolStateSnapshot(GetLatestProtocolStateSnapshotRequest)
      returns (ProtocolStateSnapshotResponse);

  // GetProtocolStateSnapshotByBlockID retrieves the latest sealed protocol
  // state snapshot by block ID. Used by Flow nodes joining the network to
  // bootstrap a space-efficient local state.
  rpc GetProtocolStateSnapshotByBlockID(
      GetProtocolStateSnapshotByBlockIDRequest)
      returns (ProtocolStateSnapshotResponse);

  // GetProtocolStateSnapshotByHeight retrieves the latest sealed protocol state
  // snapshot by block height. Used by Flow nodes joining the network to
  // bootstrap a space-efficient local state.
  rpc GetProtocolStateSnapshotByHeight(GetProtocolStateSnapshotByHeightRequest)
      returns (ProtocolStateSnapshotResponse);

  // GetExecutionResultForBlockID returns Execution Result for a given block.
  // At present, Access Node might not have execution results for every block
  // and as usual, until sealed, this data can change
  rpc GetExecutionResultForBlockID(GetExecutionResultForBlockIDRequest)
      returns (ExecutionResultForBlockIDResponse);

  // GetExecutionResultByID returns Execution Result by its ID.
  rpc GetExecutionResultByID(GetExecutionResultByIDRequest)
      returns (ExecutionResultByIDResponse);

  // GetExecutionReceiptsByBlockID returns all execution receipts for a given
  // block ID. Optionally includes the full ExecutionResult in each receipt.
  rpc GetExecutionReceiptsByBlockID(GetExecutionReceiptsByBlockIDRequest)
      returns (ExecutionReceiptsResponse);

  // GetExecutionReceiptsByResultID returns all execution receipts for a given
  // execution result ID. Optionally includes the full ExecutionResult in each
  // receipt.
  rpc GetExecutionReceiptsByResultID(GetExecutionReceiptsByResultIDRequest)
      returns (ExecutionReceiptsResponse);

  // Subscriptions

  // Subscribe blocks

  // SubscribeBlocksFromStartBlockID streams finalized or sealed blocks starting
  // at the requested start block id, up until the latest available block. Once
  // the latest is reached, the stream will remain open and responses are sent
  // for each new block as it becomes available.
  //
  // Blocks are only returned when they have reached the provided block status.
  // For example, if the status is "sealed", only sealed blocks will be
  // returned.
  rpc SubscribeBlocksFromStartBlockID(SubscribeBlocksFromStartBlockIDRequest)
      returns (stream SubscribeBlocksResponse);

  // SubscribeBlocksFromStartHeight streams finalized or sealed blocks starting
  // at the requested start block height, up until the latest available block.
  // Once the latest is reached, the stream will remain open and responses are
  // sent for each new block as it becomes available.
  //
  // Blocks are only returned when they have reached the provided block status.
  // For example, if the status is "sealed", only sealed blocks will be
  // returned.
  rpc SubscribeBlocksFromStartHeight(SubscribeBlocksFromStartHeightRequest)
      returns (stream SubscribeBlocksResponse);

  // SubscribeBlocksFromLatest streams finalized or sealed blocks starting from
  // the latest finalized or sealed block. The stream will remain open and
  // responses are sent for each new block as it becomes available.
  //
  // Blocks are only returned when they have reached the provided block status.
  // For example, if the status is "sealed", only sealed blocks will be
  // returned.
  rpc SubscribeBlocksFromLatest(SubscribeBlocksFromLatestRequest)
      returns (stream SubscribeBlocksResponse);

  // Subscribe block headers

  // SubscribeBlockHeadersFromStartBlockID streams finalized or sealed block
  // headers starting at the requested start block id, up until the latest
  // available block. Once the latest is reached, the stream will remain open
  // and responses are sent for each new block header as it becomes available.
  //
  // Block headers are only returned when they have reached the provided block
  // status. For example, if the status is "sealed", only sealed block headers
  // will be returned.
  rpc SubscribeBlockHeadersFromStartBlockID(
      SubscribeBlockHeadersFromStartBlockIDRequest)
      returns (stream SubscribeBlockHeadersResponse);

  // SubscribeBlockHeadersFromStartHeight streams finalized or sealed block
  // headers starting at the requested start block height, up until the latest
  // available block. Once the latest is reached, the stream will remain open
  // and responses are sent for each new block header as it becomes available.
  //
  // Block headers are only returned when they have reached the provided block
  // status. For example, if the status is "sealed", only sealed block headers
  // will be returned.
  rpc SubscribeBlockHeadersFromStartHeight(
      SubscribeBlockHeadersFromStartHeightRequest)
      returns (stream SubscribeBlockHeadersResponse);

  // SubscribeBlockHeadersFromLatest streams finalized or sealed block headers
  // starting from the latest finalized or sealed block. The stream will remain
  // open and responses are sent for each new block header as it becomes
  // available.
  //
  // Block headers are only returned when they have reached the provided block
  // status. For example, if the status is "sealed", only sealed block headers
  // will be returned.
  rpc SubscribeBlockHeadersFromLatest(SubscribeBlockHeadersFromLatestRequest)
      returns (stream SubscribeBlockHeadersResponse);

  // Subscribe block digests

  // SubscribeBlockDigestsFromStartBlockID streams finalized or sealed
  // lightweight block starting at the requested start block id, up until the
  // latest available block. Once the latest is reached, the stream will remain
  // open and responses are sent for each new lightweight block as it becomes
  // available.
  //
  // Lightweight blocks are only returned when they have reached the provided
  // block status. For example, if the status is "sealed", only sealed
  // lightweight blocks will be returned.
  rpc SubscribeBlockDigestsFromStartBlockID(
      SubscribeBlockDigestsFromStartBlockIDRequest)
      returns (stream SubscribeBlockDigestsResponse);

  // SubscribeBlockDigestsFromStartHeight streams finalized or sealed
  // lightweight block starting at the requested start block height, up until
  // the latest available block. Once the latest is reached, the stream will
  // remain open and responses are sent for each new lightweight block as it
  // becomes available.
  //
  // Lightweight blocks are only returned when they have reached the provided
  // block status. For example, if the status is "sealed", only sealed
  // lightweight blocks will be returned.
  rpc SubscribeBlockDigestsFromStartHeight(
      SubscribeBlockDigestsFromStartHeightRequest)
      returns (stream SubscribeBlockDigestsResponse);

  // SubscribeBlockDigestsFromLatest streams finalized or sealed lightweight
  // block headers starting of the latest finalized or sealed block. The stream
  // will remain open and responses are sent for each new lightweight block as
  // it becomes available.
  //
  // Lightweight blocks are only returned when they have reached the provided
  // block status. For example, if the status is "sealed", only sealed
  // lightweight blocks will be returned.
  rpc SubscribeBlockDigestsFromLatest(SubscribeBlockDigestsFromLatestRequest)
      returns (stream SubscribeBlockDigestsResponse);

  // Subscribe transaction statuses

  // SendAndSubscribeTransactionStatuses send a transaction and immediately
  // subscribe to its status changes. The status is streamed back until the
  // block containing the transaction becomes sealed.
  rpc SendAndSubscribeTransactionStatuses(
      SendAndSubscribeTransactionStatusesRequest)
      returns (stream SendAndSubscribeTransactionStatusesResponse);
}

message PingRequest {}

message PingResponse {}

message GetNodeVersionInfoRequest {}

message GetNodeVersionInfoResponse {
  entities.NodeVersionInfo info = 1;
}

// Block Headers

message GetLatestBlockHeaderRequest {
  bool is_sealed = 1;
}

message GetBlockHeaderByIDRequest {
  bytes id = 1;
}

message GetBlockHeaderByHeightRequest {
  uint64 height = 1;
}

message BlockHeaderResponse {
  entities.BlockHeader block = 1;
  entities.BlockStatus block_status = 2;
  entities.Metadata metadata = 3;
}

// Blocks

message GetLatestBlockRequest {
  bool is_sealed = 1;
  bool full_block_response = 2;
}

message GetBlockByIDRequest {
  bytes id = 1;
  bool full_block_response = 2;
}

message GetBlockByHeightRequest {
  uint64 height = 1;
  bool full_block_response = 2;
}

message BlockResponse {
  entities.Block block = 1;
  entities.BlockStatus block_status = 2;
  entities.Metadata metadata = 3;
}

// Collections

message GetCollectionByIDRequest {
  bytes id = 1;
  entities.ExecutionStateQuery execution_state_query = 2;
}

message GetFullCollectionByIDRequest {
  bytes id = 1;
  entities.ExecutionStateQuery execution_state_query = 2;
}

message CollectionResponse {
  entities.Collection collection = 1;
  entities.Metadata metadata = 2;
}

message FullCollectionResponse {
  repeated entities.Transaction transactions = 1;
  entities.Metadata metadata = 2;
}

// Transactions

message SendTransactionRequest {
  entities.Transaction transaction = 1;
  entities.ExecutionStateQuery execution_state_query = 2;
}

message SendTransactionResponse {
  bytes id = 1;
  entities.Metadata metadata = 2;
}

message GetTransactionRequest {
  bytes id = 1;
  bytes block_id = 2;
  bytes collection_id = 3;
  entities.EventEncodingVersion event_encoding_version = 4;
  entities.ExecutionStateQuery execution_state_query = 5;
}

message GetSystemTransactionRequest {
  // BlockID of the block that contains the system transaction.
  bytes block_id = 1;

  // ID of the system transaction. [optional]
  // If unset, the last system transaction is returned.
  bytes id = 2;

  // Execution state query parameters used for unsealed blocks. [optional]
  entities.ExecutionStateQuery execution_state_query = 3;
}

message GetSystemTransactionResultRequest {
  // BlockID of the block that contains the system transaction.
  bytes block_id = 1;

  // Desired event payload encoding.
  entities.EventEncodingVersion event_encoding_version = 2;

  // Execution state query parameters used for unsealed blocks. [optional]
  entities.ExecutionStateQuery execution_state_query = 3;

  // ID of the system transaction. [optional]
  // If unset, the result of the last system transaction is returned.
  bytes id = 4;
}

message GetScheduledTransactionRequest {
  // id field of the scheduled transaction returned by the system contract.
  uint64 id = 1;

  // Execution state query parameters used for unsealed blocks. [optional]
  entities.ExecutionStateQuery execution_state_query = 2;
}

message GetScheduledTransactionResultRequest {
  // id field of the scheduled transaction returned by the system contract.
  uint64 id = 1;

  // Desired event payload encoding.
  entities.EventEncodingVersion event_encoding_version = 2;

  // Execution state query parameters used for unsealed blocks. [optional]
  entities.ExecutionStateQuery execution_state_query = 3;
}

message GetTransactionByIndexRequest {
  bytes block_id = 1;
  uint32 index = 2;
  entities.EventEncodingVersion event_encoding_version = 3;
  entities.ExecutionStateQuery execution_state_query = 4;
}

message GetTransactionsByBlockIDRequest {
  bytes block_id = 1;
  entities.EventEncodingVersion event_encoding_version = 2;
  entities.ExecutionStateQuery execution_state_query = 3;
}

message TransactionResultsResponse {
  repeated TransactionResultResponse transaction_results = 1;
  entities.Metadata metadata = 2;
}

message TransactionsResponse {
  repeated entities.Transaction transactions = 1;
  entities.Metadata metadata = 2;
}

message TransactionResponse {
  entities.Transaction transaction = 1;
  entities.Metadata metadata = 2;
}

message TransactionResultResponse {
  entities.TransactionStatus status = 1;
  uint32 status_code = 2;
  string error_message = 3;
  repeated entities.Event events = 4;
  bytes block_id = 5;
  bytes transaction_id = 6;
  bytes collection_id = 7;
  uint64 block_height = 8;
  entities.Metadata metadata = 9;
  uint64 computation_usage = 10;
}

// Accounts

message GetAccountRequest {
  bytes address = 1;
  entities.ExecutionStateQuery execution_state_query = 2;
}

message GetAccountResponse {
  entities.Account account = 1;
  entities.Metadata metadata = 2;
}

message GetAccountAtLatestBlockRequest {
  bytes address = 1;
  entities.ExecutionStateQuery execution_state_query = 2;
}

message AccountResponse {
  entities.Account account = 1;
  entities.Metadata metadata = 2;
}

message GetAccountAtBlockHeightRequest {
  bytes address = 1;
  uint64 block_height = 2;
  entities.ExecutionStateQuery execution_state_query = 3;
}

message GetAccountBalanceAtLatestBlockRequest {
  bytes address = 1;
  entities.ExecutionStateQuery execution_state_query = 2;
}

message GetAccountBalanceAtBlockHeightRequest {
  bytes address = 1;
  uint64 block_height = 2;
  entities.ExecutionStateQuery execution_state_query = 3;
}

message AccountBalanceResponse {
  uint64 balance = 1;
  entities.Metadata metadata = 2;
}

message GetAccountKeysAtLatestBlockRequest {
  // address of account
  bytes address = 1;
  entities.ExecutionStateQuery execution_state_query = 2;
}

message GetAccountKeyAtLatestBlockRequest {
  // address of account
  bytes address = 1;
  // index of key to return
  uint32 index = 2;
  entities.ExecutionStateQuery execution_state_query = 3;
}

message GetAccountKeysAtBlockHeightRequest {
  bytes address = 1;
  uint64 block_height = 2;
  entities.ExecutionStateQuery execution_state_query = 3;
}

message GetAccountKeyAtBlockHeightRequest {
  bytes address = 1;
  uint64 block_height = 2;
  // index of key to return
  uint32 index = 3;
  entities.ExecutionStateQuery execution_state_query = 4;
}

message AccountKeysResponse {
  repeated entities.AccountKey account_keys = 1;
  entities.Metadata metadata = 2;
}

message AccountKeyResponse {
  entities.AccountKey account_key = 1;
  entities.Metadata metadata = 2;
}

// Scripts

message ExecuteScriptAtLatestBlockRequest {
  bytes script = 1;
  repeated bytes arguments = 2;
  entities.ExecutionStateQuery execution_state_query = 3;
}

message ExecuteScriptAtBlockIDRequest {
  bytes block_id = 1;
  bytes script = 2;
  repeated bytes arguments = 3;
  entities.ExecutionStateQuery execution_state_query = 4;
}

message ExecuteScriptAtBlockHeightRequest {
  uint64 block_height = 1;
  bytes script = 2;
  repeated bytes arguments = 3;
  entities.ExecutionStateQuery execution_state_query = 4;
}

message ExecuteScriptResponse {
  bytes value = 1;
  entities.Metadata metadata = 2;
  uint64 computation_usage = 3;
}

// Events

message GetEventsForHeightRangeRequest {
  string type = 1;
  uint64 start_height = 2;
  uint64 end_height = 3;
  entities.EventEncodingVersion event_encoding_version = 4;
  entities.ExecutionStateQuery execution_state_query = 5;
}

message GetEventsForBlockIDsRequest {
  string type = 1;
  repeated bytes block_ids = 2;
  entities.EventEncodingVersion event_encoding_version = 3;
  entities.ExecutionStateQuery execution_state_query = 4;
}

message EventsResponse {
  message Result {
    bytes block_id = 1;
    uint64 block_height = 2;
    repeated entities.Event events = 3;
    google.protobuf.Timestamp block_timestamp = 4;
  }
  repeated Result results = 1;
  entities.Metadata metadata = 2;
}

// Network Parameters

message GetNetworkParametersRequest {}

message GetNetworkParametersResponse {
  string chain_id = 1;
}

// Protocol State

message GetLatestProtocolStateSnapshotRequest {}

message GetProtocolStateSnapshotByBlockIDRequest {
  bytes block_id = 1;
}

message GetProtocolStateSnapshotByHeightRequest {
  uint64 block_height = 1;
}

message ProtocolStateSnapshotResponse {
  bytes serializedSnapshot = 1;
  entities.Metadata metadata = 2;
}

// Execution Results

message GetExecutionResultForBlockIDRequest {
  bytes block_id = 1;
  entities.ExecutionStateQuery execution_state_query = 2;
}

message ExecutionResultForBlockIDResponse {
  entities.ExecutionResult execution_result = 1;
  entities.Metadata metadata = 2;
}

message GetExecutionResultByIDRequest {
  bytes id = 1;
  entities.ExecutionStateQuery execution_state_query = 2;
}

message ExecutionResultByIDResponse {
  entities.ExecutionResult execution_result = 1;
  entities.Metadata metadata = 2;
}

// Execution Receipts

message GetExecutionReceiptsByBlockIDRequest {
  bytes block_id = 1;
  // If true, each receipt will include the full ExecutionResult.
  bool include_result = 2;
}

message GetExecutionReceiptsByResultIDRequest {
  bytes result_id = 1;
  // If true, each receipt will include the full ExecutionResult.
  bool include_result = 2;
}

message ExecutionReceiptsResponse {
  repeated entities.ExecutionReceipt receipts = 1;
  entities.Metadata metadata = 2;
}

// Subscriptions

// Subscribe blocks

// The request for SubscribeBlocksFromStartBlockID
message SubscribeBlocksFromStartBlockIDRequest {
  // Block ID of the first block to subscribe.
  bytes start_block_id = 1;

  // Required block status of the block payload.
  // Possible variants:
  // 1. BLOCK_FINALIZED
  // 2. BLOCK_SEALED
  entities.BlockStatus block_status = 2;

  // Boolean value determining the response: 'full' if `true`, 'light'
  // otherwise.
  bool full_block_response = 3;
}

// The request for SubscribeBlocksFromStartHeight
message SubscribeBlocksFromStartHeightRequest {
  // Block height of the first block to subscribe.
  uint64 start_block_height = 1;

  // Required block status of the block payload.
  // Possible variants:
  // 1. BLOCK_FINALIZED
  // 2. BLOCK_SEALED
  entities.BlockStatus block_status = 2;

  // Boolean value determining the response: 'full' if `true`, 'light'
  // otherwise.
  bool full_block_response = 3;
}

// The request for SubscribeBlocksFromLatest
message SubscribeBlocksFromLatestRequest {
  // Required block status of the block payload.
  // Possible variants:
  // 1. BLOCK_FINALIZED
  // 2. BLOCK_SEALED
  entities.BlockStatus block_status = 1;

  // Boolean value determining the response: 'full' if `true`, 'light'
  // otherwise.
  bool full_block_response = 2;
}

// The response for SubscribeBlocksFromStartBlockID,
// SubscribeBlocksFromStartHeight, SubscribeBlocksFromLatest
message SubscribeBlocksResponse {
  // The sealed or finalized blocks according to the block status
  // in the request.
  entities.Block block = 1;
}

// Subscribe block headers

// The request for SubscribeBlockHeadersFromStartBlockID
message SubscribeBlockHeadersFromStartBlockIDRequest {
  // Block ID of the first block header to subscribe.
  bytes start_block_id = 1;

  // Required block status of the block payload.
  // Possible variants:
  // 1. BLOCK_FINALIZED
  // 2. BLOCK_SEALED
  entities.BlockStatus block_status = 2;
}

// The request for SubscribeBlockHeadersFromStartHeight
message SubscribeBlockHeadersFromStartHeightRequest {
  // Block height of the first block header to subscribe.
  uint64 start_block_height = 1;

  // Required block status of the block payload.
  // Possible variants:
  // 1. BLOCK_FINALIZED
  // 2. BLOCK_SEALED
  entities.BlockStatus block_status = 2;
}

// The request for SubscribeBlockHeadersFromLatest
message SubscribeBlockHeadersFromLatestRequest {
  // Required block status of the block payload.
  // Possible variants:
  // 1. BLOCK_FINALIZED
  // 2. BLOCK_SEALED
  entities.BlockStatus block_status = 1;
}

// The response for SubscribeBlockHeadersFromStartBlockID,
// SubscribeBlockHeadersFromStartHeight, SubscribeBlockHeadersFromLatest
message SubscribeBlockHeadersResponse {
  // The sealed or finalized block headers according to the block status
  // in the request.
  entities.BlockHeader header = 1;
}

// Subscribe block digests

// The request for SubscribeBlockDigestsFromStartBlockID
message SubscribeBlockDigestsFromStartBlockIDRequest {
  // Block ID of the first block to subscribe.
  bytes start_block_id = 1;

  // Required block status of the block payload.
  // Possible variants:
  // 1. BLOCK_FINALIZED
  // 2. BLOCK_SEALED
  entities.BlockStatus block_status = 2;
}

// The request for SubscribeBlockDigestsFromStartHeight
message SubscribeBlockDigestsFromStartHeightRequest {
  // Block height of the first block to subscribe.
  uint64 start_block_height = 1;

  // Required block status of the block payload.
  // Possible variants:
  // 1. BLOCK_FINALIZED
  // 2. BLOCK_SEALED
  entities.BlockStatus block_status = 2;
}

// The request for SubscribeBlockDigestsFromLatest
message SubscribeBlockDigestsFromLatestRequest {
  // Required block status of the block payload.
  // Possible variants:
  // 1. BLOCK_FINALIZED
  // 2. BLOCK_SEALED
  entities.BlockStatus block_status = 1;
}

// The response for SubscribeBlockDigestsFromStartBlockID,
// SubscribeBlockDigestsFromStartHeight, SubscribeBlockDigestsFromLatest
message SubscribeBlockDigestsResponse {
  // The block ID of the new sealed or finalized block according to the block
  // status in the request.
  bytes block_id = 1;
  // The block height of the new sealed or finalized block according to the
  // block status in the request.
  uint64 block_height = 2;
  // The timestamp of the new sealed or finalized block according to the block
  // status in the request.
  google.protobuf.Timestamp block_timestamp = 3;
}

// Request message for sending a transaction and subscribing to its status
// changes.
message SendAndSubscribeTransactionStatusesRequest {
  // The transaction to be sent and tracked for status changes.
  entities.Transaction transaction = 1;
  // The encoding for events in transaction result
  entities.EventEncodingVersion event_encoding_version = 2;
  entities.ExecutionStateQuery execution_state_query = 3;
}

// Response message for transaction status changes.
message SendAndSubscribeTransactionStatusesResponse {
  // Transaction result of the tracked transaction
  TransactionResultResponse transaction_results = 1;
  // The message index of the response message. Used by the client to ensure
  // they received all messages. Starts from "0".
  uint64 message_index = 2;
}