node_call_types.h

Go to the documentation of this file.

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the Apache 2.0 License.
#pragma once
 
#include "ccf/ds/json_schema.h"
#include "ccf/node_startup_state.h"
#include "ccf/pal/mem.h"
#include "ccf/service/node_info_network.h"
#include "ccf/service/tables/code_id.h"
#include "ccf/service/tables/host_data.h"
#include "ccf/service/tables/members.h"
#include "ccf/service/tables/service.h"
#include "common/configuration.h"
#include "enclave/interface.h"
#include "node/identity.h"
#include "node/ledger_secrets.h"
#include "node/rpc/cose_signatures_config.h"
#include "node/uvm_endorsements.h"
 
#include <nlohmann/json.hpp>
 
namespace ccf
{
  struct GetState
  {
    using In = void;
 
    struct Out
    {
      ccf::NodeId node_id;
      ccf::NodeStartupState state;
      ccf::kv::Version last_signed_seqno;
      ccf::kv::Version startup_seqno;
 
      // Only on recovery
      std::optional<ccf::kv::Version> recovery_target_seqno;
      std::optional<ccf::kv::Version> last_recovered_seqno;
 
      bool stop_notice;
    };
  };
 
  struct GetVersion
  {
    using In = void;
 
    struct Out
    {
      std::string ccf_version;
      std::string quickjs_version;
      bool unsafe;
    };
  };
 
  struct CreateNetworkNodeToNode
  {
    struct In
    {
      NodeId node_id;
      ccf::crypto::Pem certificate_signing_request;
      ccf::crypto::Pem node_endorsed_certificate;
      ccf::crypto::Pem public_key;
      ccf::crypto::Pem service_cert;
      QuoteInfo quote_info;
      ccf::crypto::Pem public_encryption_key;
      pal::PlatformAttestationMeasurement measurement;
      std::optional<HostDataMetadata> snp_security_policy =
        std::nullopt; // base64-encoded
      std::optional<UVMEndorsements> snp_uvm_endorsements = std::nullopt;
      NodeInfoNetwork node_info_network;
      nlohmann::json node_data;
      nlohmann::json service_data;
      ccf::TxID create_txid;
 
      // Only set on genesis transaction, but not on recovery
      std::optional<StartupConfig::Start> genesis_info = std::nullopt;
      // Constitution to set on recovery
      std::optional<std::string> recovery_constitution = std::nullopt;
    };
  };
 
  struct JoinNetworkNodeToNode
  {
    struct In
    {
      NodeInfoNetwork node_info_network;
      QuoteInfo quote_info;
      ccf::crypto::Pem public_encryption_key;
      // Always set by the joiner (node_state.h), but defaults to nullopt here
      // to make sure serialisation does take place now that it is OPTIONAL.
      std::optional<ConsensusType> consensus_type = std::nullopt;
      std::optional<ccf::kv::Version> startup_seqno = std::nullopt;
      std::optional<ccf::crypto::Pem> certificate_signing_request =
        std::nullopt;
      nlohmann::json node_data = nullptr;
    };
 
    struct Out
    {
      NodeStatus node_status;
 
      // Deprecated in 2.x
      std::optional<NodeId> node_id = std::nullopt;
 
      struct NetworkInfo
      {
        bool public_only = false;
        ccf::kv::Version last_recovered_signed_idx = ccf::kv::NoVersion;
        ConsensusType consensus_type = ConsensusType::CFT;
        std::optional<ReconfigurationType> reconfiguration_type =
          std::nullopt; // Unused, but kept for backwards compatibility
 
        LedgerSecretsMap ledger_secrets;
        NetworkIdentity identity;
        std::optional<ServiceStatus> service_status = std::nullopt;
 
        std::optional<ccf::crypto::Pem> endorsed_certificate = std::nullopt;
        std::optional<COSESignaturesConfig> cose_signatures_config =
          std::nullopt;
 
        NetworkInfo() {}
 
        NetworkInfo(
          bool public_only,
          ccf::kv::Version last_recovered_signed_idx,
          ReconfigurationType reconfiguration_type,
          const LedgerSecretsMap& ledger_secrets,
          const NetworkIdentity& identity,
          ServiceStatus service_status,
          const std::optional<ccf::crypto::Pem>& endorsed_certificate,
          const std::optional<COSESignaturesConfig>& cose_signatures_config_) :
          public_only(public_only),
          last_recovered_signed_idx(last_recovered_signed_idx),
          reconfiguration_type(reconfiguration_type),
          ledger_secrets(ledger_secrets),
          identity(identity),
          service_status(service_status),
          endorsed_certificate(endorsed_certificate),
          cose_signatures_config(cose_signatures_config_)
        {}
 
        bool operator==(const NetworkInfo& other) const
        {
          return public_only == other.public_only &&
            last_recovered_signed_idx == other.last_recovered_signed_idx &&
            consensus_type == other.consensus_type &&
            reconfiguration_type == other.reconfiguration_type &&
            ledger_secrets == other.ledger_secrets &&
            identity == other.identity &&
            service_status == other.service_status &&
            endorsed_certificate == other.endorsed_certificate &&
            cose_signatures_config == other.cose_signatures_config;
        }
 
        bool operator!=(const NetworkInfo& other) const
        {
          return !(*this == other);
        }
      };
 
      // Only set if the caller node is trusted
      std::optional<NetworkInfo> network_info = std::nullopt;
    };
  };
 
  struct MemoryUsage
  {
    using In = void;
 
    struct Out
    {
      Out(const pal::MallocInfo& info) :
        max_total_heap_size(info.max_total_heap_size),
        current_allocated_heap_size(info.current_allocated_heap_size),
        peak_allocated_heap_size(info.peak_allocated_heap_size)
      {}
      Out() = default;
 
      size_t max_total_heap_size = 0;
      size_t current_allocated_heap_size = 0;
      size_t peak_allocated_heap_size = 0;
    };
  };
}