CCF
Loading...
Searching...
No Matches
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
ccf Namespace Reference

Namespaces

namespace  consensus
 
namespace  cose
 
namespace  crypto
 
namespace  curl
 
namespace  ds
 
namespace  endpoints
 
namespace  env
 
namespace  errors
 
namespace  gov
 
namespace  historical
 
namespace  http
 
namespace  http2
 
namespace  indexing
 
namespace  js
 
namespace  jsgov
 
namespace  jsonhandler
 
namespace  kv
 
namespace  logger
 
namespace  nonstd
 
namespace  pal
 
namespace  siphash
 
namespace  Tables
 
namespace  threading
 
namespace  tls
 

Classes

class  AbstractCOSESignaturesConfigSubsystem
 
class  AbstractForwarder
 
class  AbstractGovernanceEffects
 
class  AbstractHostProcesses
 
struct  AbstractNodeContext
 
class  AbstractNodeOperation
 
class  AbstractNodeState
 
class  AbstractNodeSubSystem
 
class  AbstractRPCResponder
 
class  ACMEChallengeHandler
 
class  ACMEClient
 
struct  ACMEClientConfig
 
class  ACMERpcEndpoints
 
class  ACMERpcFrontend
 
class  ACMESubsystem
 
class  ACMESubsystemInterface
 
class  ActiveMemberCOSESign1AuthnPolicy
 
struct  AllOfAuthnIdentity
 
class  AllOfAuthnPolicy
 
struct  AnyCertAuthnIdentity
 
class  AnyCertAuthnPolicy
 
struct  Attestation
 
class  AttestationProvider
 
struct  AuditInfo
 
struct  AuthnIdentity
 
class  AuthnPolicy
 
class  BaseEndpointRegistry
 
class  ccf_logic_error
 
class  ccf_openssl_rdrand_init_error
 
struct  CCFConfig
 
class  Channel
 
struct  ChannelHeader
 
class  ClaimsDigest
 
class  ClientSession
 
class  CommonEndpointRegistry
 
class  ConfigurationChangeHook
 
struct  ConsensusConfigDetails
 
struct  ConsensusNodeConfig
 
struct  CoseEndorsement
 
struct  COSESign1AuthnIdentity
 
struct  COSESignaturesConfig
 
struct  CreateNetworkNodeToNode
 
class  CustomProtocolSubsystem
 
class  CustomProtocolSubsystemInterface
 
struct  EmptyAuthnIdentity
 
class  EmptyAuthnPolicy
 
class  Enclave
 
struct  EncryptedLedgerSecret
 
struct  EncryptedLedgerSecretInfo
 
class  EncryptedSession
 
struct  Endorsement
 
struct  EndpointContextImpl
 
struct  EndpointMetrics
 
struct  EndpointMetricsEntry
 
struct  EntityId
 
struct  ErrorDetails
 
struct  ForwardedCommandHeader_v3
 
struct  ForwardedHeader_v1
 
struct  ForwardedHeader_v2
 
struct  ForwardedResponseHeader_v3
 
class  ForwardedRpcHandler
 
class  Forwarder
 
struct  GetAPI
 
struct  GetAttestations
 
struct  GetCode
 
struct  GetCommit
 
struct  GetNetworkInfo
 
struct  GetNode
 
struct  GetNodes
 
struct  GetQuotes
 
struct  GetRecoveryShare
 
struct  GetServicePreviousIdentity
 
struct  GetSnpHostDataMap
 
struct  GetState
 
struct  GetTxStatus
 
struct  GetVersion
 
class  GovEndpointRegistry
 
class  GovernanceEffects
 
struct  GovernanceProtectedHeader
 
class  HashedTxHistory
 
class  HostProcesses
 
class  HTTPNodeClient
 
class  InternalTablesAccess
 
struct  JavaScriptMetrics
 
struct  JoinNetworkNodeToNode
 
struct  JsonField
 
class  JsonParseError
 
struct  JsonWebKeySet
 
struct  JSRuntimeOptions
 
struct  JwtAuthnIdentity
 
class  JwtAuthnPolicy
 
struct  JwtIssuerMetadata
 
class  JwtKeyAutoRefresh
 
struct  JWTRefreshMetrics
 
struct  LedgerSecret
 
class  LedgerSecrets
 
class  LedgerSecretsBroadcast
 
struct  MemberAck
 
struct  MemberCertAuthnIdentity
 
class  MemberCertAuthnPolicy
 
struct  MemberCOSESign1AuthnIdentity
 
class  MemberCOSESign1AuthnPolicy
 
struct  MemberDetails
 
struct  MemberIdFormatter
 
class  MemberRpcFrontend
 
struct  MemoryUsage
 
class  MerkleTreeHistory
 
class  MerkleTreeHistoryPendingTx
 
struct  MessageHash
 
struct  NetworkIdentity
 
class  NetworkIdentitySubsystem
 
class  NetworkIdentitySubsystemInterface
 
struct  NetworkState
 
struct  NetworkTables
 
struct  NewMember
 
struct  NewUser
 
struct  NodeAddr
 
struct  NodeCertAuthnIdentity
 
class  NodeCertAuthnPolicy
 
class  NodeClient
 
class  NodeConfigurationInterface
 
struct  NodeConfigurationState
 
class  NodeConfigurationSubsystem
 
struct  NodeCreateInfo
 
class  NodeEndpoints
 
struct  NodeIdFormatter
 
struct  NodeInfo
 
struct  NodeInfoNetwork
 
struct  NodeInfoNetwork_v1
 
struct  NodeInfoNetwork_v2
 Node network information. More...
 
struct  NodeMetrics
 
class  NodeOperation
 
class  NodeRpcFrontend
 
struct  NodeSignature
 
class  NodeState
 
class  NodeToNode
 
class  NodeToNodeChannelManager
 
class  NullTxHistory
 
class  NullTxHistoryPendingTx
 
struct  ODataAuthErrorDetails
 
struct  ODataError
 
struct  ODataErrorResponse
 
struct  ODataJSExceptionDetails
 
struct  OpenIDJWKMetadata
 
struct  OpenIDJWKMetadataLegacy
 
struct  PreviousLedgerSecretInfo
 
struct  PrimarySignature
 
class  Proof
 
class  ProofReceipt
 
struct  ProtectedHeader
 
struct  PublicKeysCache
 
struct  Quote
 
class  QuoteEndorsementsClient
 
struct  QuoteInfo
 Describes a quote (attestation) from trusted hardware. More...
 
class  Receipt
 
class  ReconstructedLedgerSecretWrappingKey
 
struct  RecoverySharesInfo
 
struct  RedirectDetails
 
struct  RedirectionResolverConfig
 
class  RESTVerb
 
class  RetiredNodeCleanup
 
class  RpcContext
 Describes the currently executing RPC. More...
 
class  RpcContextImpl
 
struct  RpcException
 
class  RpcFrontend
 
class  RpcHandler
 
class  RPCMap
 
class  RPCSessions
 
struct  SealedLedgerSecret
 
struct  SealedLedgerSecretAAD
 
struct  SelfSignedNodeCertificateInfo
 
struct  ServiceConfiguration
 
struct  ServiceInfo
 
class  Session
 
struct  SessionContext
 
struct  SessionMetrics
 
struct  SetJwtPublicSigningKeys
 
class  SharedLedgerSecretWrappingKey
 
class  ShareManager
 
class  SignatureReceipt
 
struct  SignedReq
 
struct  SnapshotHash
 
class  Snapshotter
 
struct  StartupConfig
 
struct  StartupSnapshotInfo
 
struct  StateDigest
 
struct  SubmitRecoveryShare
 
class  ThreadedSession
 
struct  TimestampedProtectedHeader
 
class  TLSSession
 
struct  TxGcmHeader
 
struct  TxID
 
struct  TxReceiptImpl
 
class  TypedUserCOSESign1AuthnPolicy
 
class  UnencryptedSession
 
struct  UserCertAuthnIdentity
 
class  UserCertAuthnPolicy
 
struct  UserCOSESign1AuthnIdentity
 
class  UserCOSESign1AuthnPolicy
 
struct  UserDetails
 
class  UserEndpointRegistry
 
struct  UserIdFormatter
 
class  UserRpcFrontend
 
struct  UVMEndorsementsData
 
struct  UVMEndorsementsPayload
 
struct  UvmEndorsementsProtectedHeader
 
struct  ValidityPeriodsCache
 
struct  VerifyReceipt
 
struct  WireNonce
 

Typedefs

using ByteVector = llvm_vecsmall::SmallVector< uint8_t, 8 >
 
using OpenAPISecuritySchema = std::pair< std::string, nlohmann::json >
 
using AuthnPolicies = std::vector< std::shared_ptr< AuthnPolicy > >
 
using NamedAuthPolicies = std::unordered_map< std::string, std::shared_ptr< ccf::AuthnPolicy > >
 
using MemberId = EntityId< MemberIdFormatter >
 
using UserId = EntityId< UserIdFormatter >
 
using NodeId = EntityId< NodeIdFormatter >
 
using http_status = llhttp_status
 
using HandlerJsonParamsAndForward = std::function< jsonhandler::JsonAdapterResponse(endpoints::EndpointContext &ctx, nlohmann::json &&params)>
 
using ReadOnlyHandlerWithJson = std::function< jsonhandler::JsonAdapterResponse(endpoints::ReadOnlyEndpointContext &ctx, nlohmann::json &&params)>
 
using CommandHandlerWithJson = std::function< jsonhandler::JsonAdapterResponse(endpoints::CommandEndpointContext &ctx, nlohmann::json &&params)>
 
using ReceiptPtr = std::shared_ptr< Receipt >
 
using TxReceiptImplPtr = std::shared_ptr< TxReceiptImpl >
 
using SerialisedCoseEndorsement = std::vector< uint8_t >
 
using SerialisedCoseSignature = std::vector< uint8_t >
 
using SerialisedCoseEndorsements = std::vector< SerialisedCoseEndorsement >
 
using ListenInterfaceID = std::string
 
using PathParams = std::map< std::string, std::string, std::less<> >
 
using SeqNoCollection = ccf::ds::ContiguousSet< ccf::SeqNo >
 
template<typename K , typename V >
using ServiceMap = ccf::kv::MapSerialisedWith< K, V, ccf::kv::serialisers::BlitSerialiser, ccf::kv::serialisers::JsonSerialiser >
 
template<typename V >
using ServiceValue = ccf::kv::ValueSerialisedWith< V, ccf::kv::serialisers::JsonSerialiser, ccf::kv::serialisers::ZeroBlitUnitCreator >
 
template<typename K >
using ServiceSet = ccf::kv::SetSerialisedWith< K, ccf::kv::serialisers::BlitSerialiser, ccf::kv::serialisers::ZeroBlitUnitCreator >
 
using ApplicationProtocol = std::string
 
using ACMECertificates = ServiceMap< std::string, ccf::crypto::Pem >
 
using CACertBundlePEMs = ServiceMap< std::string, std::string >
 
using CodeIDs = ServiceMap< pal::SgxAttestationMeasurement, CodeStatus >
 
using Constitution = ServiceValue< std::string >
 
using SnpHostDataMap = ServiceMap< HostData, HostDataMetadata >
 
using VirtualHostDataMap = ServiceSet< HostData >
 
using JSEngine = ServiceValue< JSRuntimeOptions >
 
using JwtIssuer = std::string
 
using JwtKeyId = std::string
 
using Cert = std::vector< uint8_t >
 
using PublicKey = std::vector< uint8_t >
 
using JwtPublicSigningKeysMetadata = ServiceMap< JwtKeyId, std::vector< OpenIDJWKMetadata > >
 
using JwtPublicSigningKeysMetadataLegacy = ServiceMap< JwtKeyId, std::vector< OpenIDJWKMetadataLegacy > >
 
using JwtIssuers = ServiceMap< JwtIssuer, JwtIssuerMetadata >
 
using MemberInfo = ServiceMap< MemberId, MemberDetails >
 
using MemberCerts = ccf::kv::RawCopySerialisedMap< MemberId, ccf::crypto::Pem >
 
using MemberPublicEncryptionKeys = ccf::kv::RawCopySerialisedMap< MemberId, ccf::crypto::Pem >
 
using MemberAcks = ServiceMap< MemberId, MemberAck >
 
using Module = std::string
 
using Modules = ccf::kv::RawCopySerialisedMap< std::string, Module >
 
using ModulesQuickJsBytecode = ccf::kv::RawCopySerialisedMap< std::string, std::vector< uint8_t > >
 
using ModulesQuickJsVersion = ccf::kv::RawCopySerialisedValue< std::string >
 
using InterpreterFlush = ServiceValue< bool >
 
using Nodes = ServiceMap< NodeId, NodeInfo >
 
using NodeEndorsedCertificates = ccf::kv::RawCopySerialisedMap< NodeId, ccf::crypto::Pem >
 
using ProposalId = std::string
 
using Service = ServiceValue< ServiceInfo >
 
using SnpMeasurements = ServiceMap< pal::SnpAttestationMeasurement, CodeStatus >
 
using SnpTcbVersionMap = ServiceMap< std::string, pal::snp::TcbVersionPolicy >
 
using UserCerts = ccf::kv::RawCopySerialisedMap< UserId, ccf::crypto::Pem >
 
using UserInfo = ServiceMap< UserId, UserDetails >
 
using DID = std::string
 
using Feed = std::string
 
using FeedToEndorsementsDataMap = std::map< Feed, UVMEndorsementsData >
 
using SNPUVMEndorsements = ServiceMap< DID, FeedToEndorsementsDataMap >
 
using VirtualMeasurements = ServiceMap< pal::VirtualAttestationMeasurement, CodeStatus >
 
using View = uint64_t
 
using SeqNo = uint64_t
 
using QUICSessionImpl = quic::QUICEchoSession
 
using MsgNonce = uint64_t
 
using GcmHdr = ccf::crypto::FixedSizeGcmHeader< sizeof(MsgNonce)>
 
using NodeEncryptor = ccf::kv::TxEncryptor< ccf::LedgerSecrets, TxGcmHeader >
 
using HistoryTree = merkle::TreeT< sha256_byte_size, ccf::sha256_history >
 
using MerkleTxHistory = HashedTxHistory< MerkleTreeHistory >
 
using LedgerSecretPtr = std::shared_ptr< LedgerSecret >
 
using LedgerSecretsMap = std::map< ccf::kv::Version, LedgerSecretPtr >
 
using VersionedLedgerSecret = LedgerSecretsMap::value_type
 
using RaftType = aft::Aft<::consensus::LedgerEnclave >
 
using Node2NodeMsg = uint64_t
 
using QuoteEndorsementsFetchedCallback = std::function< void(std::vector< uint8_t > &&endorsements)>
 
using Server = pal::snp::EndorsementEndpointsConfiguration::Server
 
using ConsensusConfig = std::map< std::string, ConsensusNodeConfig >
 
using ExtendedState = std::tuple< NodeStartupState, std::optional< ccf::kv::Version >, std::optional< ccf::kv::Version > >
 
using RecoveredEncryptedLedgerSecrets = std::list< EncryptedLedgerSecretInfo >
 
using DynamicEndpoints = ccf::ServiceMap< endpoints::EndpointKey, endpoints::EndpointProperties >
 
using GovernanceHistory = ServiceMap< MemberId, SignedReq >
 
using COSEGovernanceHistory = ServiceMap< MemberId, std::vector< uint8_t > >
 
using COSERecentProposals = ServiceMap< std::string, ProposalId >
 
using Nonce = ccf::crypto::Sha256Hash
 
using PreviousServiceIdentity = ServiceValue< ccf::crypto::Pem >
 
using PreviousServiceLastSignedRoot = ServiceValue< ccf::crypto::Sha256Hash >
 
using PreviousServiceIdentityEndorsement = ServiceValue< CoseEndorsement >
 
using LastRecoveryType = ServiceValue< RecoveryType >
 
using LedgerSecretsForNodes = std::map< NodeId, EncryptedLedgerSecrets >
 
using Secrets = ServiceValue< LedgerSecretsForNodes >
 
using EncryptedShare = std::vector< uint8_t >
 
using EncryptedSharesMap = std::map< MemberId, EncryptedShare >
 
using EncryptedLedgerSecretsInfo = ServiceValue< EncryptedLedgerSecretInfo >
 
using Signatures = ServiceValue< PrimarySignature >
 
using SerialisedMerkleTree = ccf::kv::RawCopySerialisedValue< std::vector< uint8_t > >
 
using CoseSignature = std::vector< uint8_t >
 
using CoseSignatures = ServiceValue< CoseSignature >
 
using SnapshotEvidence = ServiceValue< SnapshotHash >
 
using EncryptedSubmittedShare = std::vector< uint8_t >
 
using EncryptedSubmittedShares = ServiceMap< MemberId, EncryptedSubmittedShare >
 

Enumerations

enum class  ApiResult {
  OK = 0 , Uninitialised , InvalidArgs , NotFound ,
  InternalError
}
 
enum class  InvalidArgsReason { NoReason = 0 , ViewSmallerThanOne , ActionAlreadyApplied , StaleActionCreatedTimestamp }
 
enum  LoggerLevel {
  TRACE , DEBUG , INFO , FAIL ,
  FATAL , MAX_LOG_LEVEL
}
 
enum class  QuoteFormat { oe_sgx_v1 = 0 , insecure_virtual = 1 , amd_sev_snp_v1 = 2 }
 
enum class  FrameFormat : uint8_t { http = 0 }
 
enum class  ActionFormat { COSE = 0 , JSON = 1 }
 
enum class  QuoteVerificationResult {
  Verified = 0 , Failed , FailedMeasurementNotFound , FailedHostDataDigestNotFound ,
  FailedInvalidHostData , FailedInvalidQuotedPublicKey , FailedUVMEndorsementsNotFound , FailedInvalidCPUID ,
  FailedInvalidTcbVersion
}
 
enum class  NodeStartupState {
  uninitialized , initialized , pending , partOfPublicNetwork ,
  partOfNetwork , readingPublicLedger , readingPrivateLedger
}
 
enum  MerkleProofLabel : int64_t { MERKLE_PROOF_LEAF_LABEL = 1 , MERKLE_PROOF_PATH_LABEL = 2 }
 
enum class  CodeStatus { ALLOWED_TO_JOIN = 0 }
 
enum  ConsensusType { CFT = 0 , BFT = 1 }
 
enum class  NodeStatus { PENDING = 0 , TRUSTED = 1 , RETIRED = 2 }
 
enum class  Authority { NODE , SERVICE , ACME , UNSECURED }
 
enum class  RedirectionResolutionKind { NodeByRole , StaticAddress }
 
enum  ReconfigurationType { ONE_TRANSACTION = 0 , TWO_TRANSACTION = 1 }
 
enum class  JwtIssuerKeyFilter { All }
 
enum class  MemberStatus { ACCEPTED = 0 , ACTIVE = 1 }
 
enum class  MemberRecoveryRole { NonParticipant = 0 , Participant , Owner }
 
enum class  ProposalState {
  OPEN , ACCEPTED , WITHDRAWN , REJECTED ,
  FAILED , DROPPED
}
 
enum class  ServiceStatus { OPENING = 1 , OPEN = 2 , WAITING_FOR_RECOVERY_SHARES = 3 , RECOVERING = 4 }
 
enum class  TxStatus { Unknown , Pending , Committed , Invalid }
 
enum class  ActorsType : uint64_t {
  members = 0 , users , nodes , acme_challenge ,
  unknown
}
 
enum  SessionStatus {
  handshake , ready , closing , closed ,
  authfail , error
}
 
enum  ChannelStatus { INACTIVE = 0 , INITIATED , WAITING_FOR_FINAL , ESTABLISHED }
 
enum  HashOp { APPEND , VERIFY , ROLLBACK , COMPACT }
 
enum  NodeMsgType : Node2NodeMsg { channel_msg = 0 , consensus_msg , forwarded_msg }
 
enum  ChannelMsg : Node2NodeMsg { key_exchange_init = 0 , key_exchange_response , key_exchange_final }
 
enum  ForwardedMsg : Node2NodeMsg {
  forwarded_cmd_v1 = 0 , forwarded_response_v1 , forwarded_cmd_v2 , forwarded_response_v2 ,
  forwarded_cmd_v3 , forwarded_response_v3
}
 
enum  : ringbuffer::Message { DEFINE_RINGBUFFER_MSG_TYPE =(associate_node_address) , DEFINE_RINGBUFFER_MSG_TYPE =(associate_node_address) , DEFINE_RINGBUFFER_MSG_TYPE =(associate_node_address) }
 Node-to-node related ringbuffer messages. More...
 
enum class  HttpVersion { HTTP1 = 0 , HTTP2 }
 
enum  RecoveryType { NONE = 0 , RECOVERY_SHARES = 1 , LOCAL_UNSEALING = 2 }
 

Functions

std::unique_ptr< ccf::endpoints::EndpointRegistry > make_user_endpoints (ccf::AbstractNodeContext &context)
 
constexpr char const * api_result_to_str (ApiResult result)
 
constexpr char const * invalid_args_reason_to_str (InvalidArgsReason reason)
 
void to_json (nlohmann::json &j, const ClaimsDigest &hash)
 
void from_json (const nlohmann::json &j, ClaimsDigest &hash)
 
std::string schema_name (const ClaimsDigest *)
 
void fill_json_schema (nlohmann::json &schema, const ClaimsDigest *)
 
 DECLARE_JSON_ENUM (QuoteFormat, {{QuoteFormat::oe_sgx_v1, "OE_SGX_v1"}, {QuoteFormat::insecure_virtual, "Insecure_Virtual"}, {QuoteFormat::amd_sev_snp_v1, "AMD_SEV_SNP_v1"}})
 
 DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS (QuoteInfo)
 
 DECLARE_JSON_REQUIRED_FIELDS (QuoteInfo, format, quote, endorsements)
 
 DECLARE_JSON_OPTIONAL_FIELDS (QuoteInfo, uvm_endorsements, endorsed_tcb)
 
bool validate_issuer (const std::string &iss, const std::optional< std::string > &tid, std::string constraint)
 
template<typename FmtExtender >
void to_json (nlohmann::json &j, const EntityId< FmtExtender > &entity_id)
 
template<typename FmtExtender >
void from_json (const nlohmann::json &j, EntityId< FmtExtender > &entity_id)
 
template<typename FmtExtender >
std::string schema_name (const EntityId< FmtExtender > *)
 
template<typename FmtExtender >
void fill_json_schema (nlohmann::json &schema, const EntityId< FmtExtender > *)
 
 DECLARE_JSON_ENUM (ActionFormat, {{ActionFormat::COSE, "COSE"}, {ActionFormat::JSON, "JSON"}})
 
jsonhandler::JsonAdapterResponse make_success ()
 
jsonhandler::JsonAdapterResponse make_success (nlohmann::json &&result_payload)
 
jsonhandler::JsonAdapterResponse make_success (const nlohmann::json &result_payload)
 
jsonhandler::JsonAdapterResponse make_error (ccf::http_status status, const std::string &code, const std::string &msg)
 
jsonhandler::JsonAdapterResponse make_redirect (ccf::http_status status)
 
endpoints::EndpointFunction json_adapter (const HandlerJsonParamsAndForward &f)
 
endpoints::ReadOnlyEndpointFunction json_read_only_adapter (const ReadOnlyHandlerWithJson &f)
 
endpoints::CommandEndpointFunction json_command_adapter (const CommandHandlerWithJson &f)
 
 DECLARE_JSON_TYPE (COSESignaturesConfig)
 
 DECLARE_JSON_REQUIRED_FIELDS (COSESignaturesConfig, issuer, subject)
 
QuoteVerificationResult verify_tcb_version_against_store (ccf::kv::ReadOnlyTx &tx, const QuoteInfo &quote_info)
 
 DECLARE_JSON_TYPE (ODataAuthErrorDetails)
 
 DECLARE_JSON_REQUIRED_FIELDS (ODataAuthErrorDetails, auth_policy, code, message)
 
 DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS (ODataJSExceptionDetails)
 
 DECLARE_JSON_REQUIRED_FIELDS (ODataJSExceptionDetails, code, message)
 
 DECLARE_JSON_OPTIONAL_FIELDS (ODataJSExceptionDetails, trace)
 
 DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS (ODataError)
 
 DECLARE_JSON_REQUIRED_FIELDS (ODataError, code, message)
 
 DECLARE_JSON_OPTIONAL_FIELDS (ODataError, details)
 
 DECLARE_JSON_TYPE (ODataErrorResponse)
 
 DECLARE_JSON_REQUIRED_FIELDS (ODataErrorResponse, error)
 
nlohmann::json describe_receipt_v1 (const TxReceiptImpl &receipt)
 
ReceiptPtr describe_receipt_v2 (const TxReceiptImpl &in)
 
std::optional< std::vector< uint8_t > > describe_merkle_proof_v1 (const TxReceiptImpl &receipt)
 
std::optional< SerialisedCoseEndorsements > describe_cose_endorsements_v1 (const TxReceiptImpl &receipt)
 
std::optional< SerialisedCoseSignature > describe_cose_signature_v1 (const TxReceiptImpl &receipt)
 
void to_json (nlohmann::json &j, const ProofReceipt::Components &components)
 
void from_json (const nlohmann::json &j, ProofReceipt::Components &components)
 
std::string schema_name (const ProofReceipt::Components *)
 
void fill_json_schema (nlohmann::json &schema, const ProofReceipt::Components *)
 
void to_json (nlohmann::json &j, const ProofReceipt::ProofStep &step)
 
void from_json (const nlohmann::json &j, ProofReceipt::ProofStep &step)
 
std::string schema_name (const ProofReceipt::ProofStep *)
 
void fill_json_schema (nlohmann::json &schema, const ProofReceipt::ProofStep *)
 
void to_json (nlohmann::json &j, const ReceiptPtr &receipt)
 
void from_json (const nlohmann::json &j, ReceiptPtr &receipt)
 
std::string schema_name (const ReceiptPtr *)
 
void fill_json_schema (nlohmann::json &schema, const ReceiptPtr *)
 
template<typename T >
void add_schema_components (T &helper, nlohmann::json &schema, const ProofReceipt::Components *comp)
 
template<typename T >
void add_schema_components (T &helper, nlohmann::json &schema, const ProofReceipt::ProofStep *ps)
 
template<typename T >
void add_schema_components (T &helper, nlohmann::json &schema, const ReceiptPtr *r)
 
std::optional< ccf::ClaimsDigest::Digest > get_create_tx_claims_digest (ccf::kv::ReadOnlyTx &tx)
 
void to_json (nlohmann::json &j, const RESTVerb &verb)
 
void from_json (const nlohmann::json &j, RESTVerb &verb)
 
std::string schema_name (const RESTVerb *)
 
void fill_json_schema (nlohmann::json &schema, const RESTVerb *)
 
int run (int argc, char **argv)
 
 DECLARE_JSON_TYPE (ACMEClientConfig)
 
 DECLARE_JSON_REQUIRED_FIELDS (ACMEClientConfig, ca_certs, directory_url, service_dns_name, contact, terms_of_service_agreed, challenge_type)
 
 DECLARE_JSON_OPTIONAL_FIELDS (ACMEClientConfig, not_before, not_after, challenge_server_interface)
 
 DECLARE_JSON_ENUM (CodeStatus, {{CodeStatus::ALLOWED_TO_JOIN, "AllowedToJoin"}})
 
 DECLARE_JSON_ENUM (NodeStatus, {{NodeStatus::PENDING, "Pending"}, {NodeStatus::TRUSTED, "Trusted"}, {NodeStatus::RETIRED, "Retired"}})
 
 DECLARE_JSON_TYPE_WITH_BASE_AND_OPTIONAL_FIELDS (NodeInfo, NodeInfoNetwork)
 
 DECLARE_JSON_REQUIRED_FIELDS (NodeInfo, quote_info, encryption_pub_key, status)
 
 DECLARE_JSON_OPTIONAL_FIELDS (NodeInfo, cert, ledger_secret_seqno, code_digest, certificate_signing_request, public_key, node_data, retired_committed)
 
 DECLARE_JSON_ENUM (Authority, {{Authority::NODE, "Node"}, {Authority::SERVICE, "Service"}, {Authority::ACME, "ACME"}, {Authority::UNSECURED, "Unsecured"}})
 
 DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS (Endorsement)
 
 DECLARE_JSON_REQUIRED_FIELDS (Endorsement, authority)
 
 DECLARE_JSON_OPTIONAL_FIELDS (Endorsement, acme_configuration)
 
 DECLARE_JSON_TYPE (NodeInfoNetwork_v1)
 
 DECLARE_JSON_REQUIRED_FIELDS (NodeInfoNetwork_v1, rpchost, pubhost, nodehost, nodeport, rpcport, pubport)
 
 DECLARE_JSON_ENUM (RedirectionResolutionKind, {{RedirectionResolutionKind::NodeByRole, "NodeByRole"}, {RedirectionResolutionKind::StaticAddress, "StaticAddress"}})
 
 DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS (RedirectionResolverConfig)
 
 DECLARE_JSON_REQUIRED_FIELDS (RedirectionResolverConfig, kind)
 
 DECLARE_JSON_OPTIONAL_FIELDS (RedirectionResolverConfig, target)
 
 DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS (NodeInfoNetwork_v2::NetInterface::Redirections)
 
 DECLARE_JSON_REQUIRED_FIELDS (NodeInfoNetwork_v2::NetInterface::Redirections)
 
 DECLARE_JSON_OPTIONAL_FIELDS (NodeInfoNetwork_v2::NetInterface::Redirections, to_primary, to_backup)
 
 DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS (NodeInfoNetwork_v2::NetInterface)
 
 DECLARE_JSON_REQUIRED_FIELDS (NodeInfoNetwork_v2::NetInterface, bind_address)
 
 DECLARE_JSON_OPTIONAL_FIELDS (NodeInfoNetwork_v2::NetInterface, endorsement, max_open_sessions_soft, max_open_sessions_hard, published_address, protocol, app_protocol, http_configuration, accepted_endpoints, forwarding_timeout_ms, redirections)
 
 DECLARE_JSON_TYPE (NodeInfoNetwork_v2::ACME)
 
 DECLARE_JSON_REQUIRED_FIELDS (NodeInfoNetwork_v2::ACME, configurations)
 
 DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS (NodeInfoNetwork_v2)
 
 DECLARE_JSON_REQUIRED_FIELDS (NodeInfoNetwork_v2, node_to_node_interface, rpc_interfaces)
 
 DECLARE_JSON_OPTIONAL_FIELDS (NodeInfoNetwork_v2, acme, will_locally_seal_ledger_secrets)
 
void to_json (nlohmann::json &j, const NodeInfoNetwork &nin)
 
void from_json (const nlohmann::json &j, NodeInfoNetwork &nin)
 
void to_json (nlohmann::json &j, const JSRuntimeOptions &options)
 
void from_json (const nlohmann::json &j, JSRuntimeOptions &options)
 
std::string schema_name (const JSRuntimeOptions *)
 
void fill_json_schema (nlohmann::json &schema, const JSRuntimeOptions *)
 
 DECLARE_JSON_ENUM (JwtIssuerKeyFilter, {{JwtIssuerKeyFilter::All, "all"}})
 
 DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS (JwtIssuerMetadata)
 
 DECLARE_JSON_REQUIRED_FIELDS (JwtIssuerMetadata)
 
 DECLARE_JSON_OPTIONAL_FIELDS (JwtIssuerMetadata, ca_cert_bundle_name, auto_refresh)
 
 DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS (OpenIDJWKMetadata)
 
 DECLARE_JSON_REQUIRED_FIELDS (OpenIDJWKMetadata, issuer, public_key)
 
 DECLARE_JSON_OPTIONAL_FIELDS (OpenIDJWKMetadata, constraint)
 
 DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS (OpenIDJWKMetadataLegacy)
 
 DECLARE_JSON_REQUIRED_FIELDS (OpenIDJWKMetadataLegacy, issuer, cert)
 
 DECLARE_JSON_OPTIONAL_FIELDS (OpenIDJWKMetadataLegacy, constraint)
 
 DECLARE_JSON_ENUM (MemberStatus, {{MemberStatus::ACCEPTED, "Accepted"}, {MemberStatus::ACTIVE, "Active"}})
 
 DECLARE_JSON_ENUM (MemberRecoveryRole, {{MemberRecoveryRole::NonParticipant, "NonParticipant"}, {MemberRecoveryRole::Participant, "Participant"}, {MemberRecoveryRole::Owner, "Owner"}})
 
 DECLARE_JSON_OPTIONAL_FIELDS (NewMember, encryption_pub_key, member_data, recovery_role)
 
NodeId compute_node_id_from_pubk_der (const std::vector< uint8_t > &node_pubk_der)
 
NodeId compute_node_id_from_cert_der (const std::vector< uint8_t > &node_cert_der)
 
NodeId compute_node_id_from_kp (const ccf::crypto::KeyPairPtr &node_sign_kp)
 
 DECLARE_JSON_ENUM (ProposalState, {{ProposalState::OPEN, "Open"}, {ProposalState::ACCEPTED, "Accepted"}, {ProposalState::WITHDRAWN, "Withdrawn"}, {ProposalState::REJECTED, "Rejected"}, {ProposalState::FAILED, "Failed"}, {ProposalState::DROPPED, "Dropped"}})
 
 DECLARE_JSON_ENUM (ServiceStatus, {{ServiceStatus::OPENING, "Opening"}, {ServiceStatus::OPEN, "Open"}, {ServiceStatus::WAITING_FOR_RECOVERY_SHARES, "WaitingForRecoveryShares"}, {ServiceStatus::RECOVERING, "Recovering"}})
 
 DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS (ServiceInfo)
 
 DECLARE_JSON_REQUIRED_FIELDS (ServiceInfo, cert, status)
 
 DECLARE_JSON_OPTIONAL_FIELDS (ServiceInfo, previous_service_identity_version, recovery_count, service_data, current_service_create_txid)
 
 DECLARE_JSON_TYPE (UVMEndorsementsData)
 
 DECLARE_JSON_REQUIRED_FIELDS (UVMEndorsementsData, svn)
 
void to_json (nlohmann::json &j, const TxID &tx_id)
 
void from_json (const nlohmann::json &j, TxID &tx_id)
 
std::string schema_name (const TxID *)
 
void fill_json_schema (nlohmann::json &schema, const TxID *)
 
constexpr char const * tx_status_to_str (TxStatus status)
 
 DECLARE_JSON_ENUM (TxStatus, {{TxStatus::Unknown, tx_status_to_str(TxStatus::Unknown)}, {TxStatus::Pending, tx_status_to_str(TxStatus::Pending)}, {TxStatus::Committed, tx_status_to_str(TxStatus::Committed)}, {TxStatus::Invalid, tx_status_to_str(TxStatus::Invalid)}})
 
 DECLARE_JSON_ENUM (LoggerLevel, {{LoggerLevel::TRACE, "Trace"}, {LoggerLevel::DEBUG, "Debug"}, {LoggerLevel::INFO, "Info"}, {LoggerLevel::FAIL, "Fail"}, {LoggerLevel::FATAL, "Fatal"}})
 
 DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS (CCFConfig::NodeCertificateInfo)
 
 DECLARE_JSON_OPTIONAL_FIELDS (CCFConfig::NodeCertificateInfo, subject_name, subject_alt_names, curve_id, initial_validity_days)
 
 DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS (CCFConfig::Ledger)
 
 DECLARE_JSON_REQUIRED_FIELDS (CCFConfig::Ledger)
 
 DECLARE_JSON_OPTIONAL_FIELDS (CCFConfig::Ledger, directory, read_only_directories, chunk_size)
 
 DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS (CCFConfig::LedgerSignatures)
 
 DECLARE_JSON_REQUIRED_FIELDS (CCFConfig::LedgerSignatures)
 
 DECLARE_JSON_OPTIONAL_FIELDS (CCFConfig::LedgerSignatures, tx_count, delay)
 
 DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS (CCFConfig::JWT)
 
 DECLARE_JSON_REQUIRED_FIELDS (CCFConfig::JWT)
 
 DECLARE_JSON_OPTIONAL_FIELDS (CCFConfig::JWT, key_refresh_interval)
 
 DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS (CCFConfig::Attestation::Environment)
 
 DECLARE_JSON_REQUIRED_FIELDS (CCFConfig::Attestation::Environment)
 
 DECLARE_JSON_OPTIONAL_FIELDS (CCFConfig::Attestation::Environment, security_policy, uvm_endorsements, snp_endorsements)
 
 DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS (CCFConfig::Attestation)
 
 DECLARE_JSON_REQUIRED_FIELDS (CCFConfig::Attestation)
 
 DECLARE_JSON_OPTIONAL_FIELDS (CCFConfig::Attestation, snp_endorsements_servers, environment, snp_security_policy_file, snp_uvm_endorsements_file, snp_endorsements_file)
 
 DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS (CCFConfig::Snapshots)
 
 DECLARE_JSON_REQUIRED_FIELDS (CCFConfig::Snapshots)
 
 DECLARE_JSON_OPTIONAL_FIELDS (CCFConfig::Snapshots, directory, tx_count, read_only_directory)
 
 DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS (CCFConfig)
 
 DECLARE_JSON_REQUIRED_FIELDS (CCFConfig, network)
 
 DECLARE_JSON_OPTIONAL_FIELDS (CCFConfig, worker_threads, node_certificate, consensus, ledger, ledger_signatures, jwt, attestation, snapshots, node_to_node_message_limit, historical_cache_soft_limit)
 
 DECLARE_JSON_TYPE (StartupConfig::Start)
 
 DECLARE_JSON_REQUIRED_FIELDS (StartupConfig::Start, members, constitution, service_configuration)
 
 DECLARE_JSON_TYPE (StartupConfig::Join)
 
 DECLARE_JSON_REQUIRED_FIELDS (StartupConfig::Join, target_rpc_address, retry_timeout, service_cert, follow_redirect)
 
 DECLARE_JSON_TYPE (StartupConfig::Recover)
 
 DECLARE_JSON_REQUIRED_FIELDS (StartupConfig::Recover, previous_service_identity, previous_sealed_ledger_secret_location)
 
 DECLARE_JSON_TYPE_WITH_BASE (StartupConfig, CCFConfig)
 
 DECLARE_JSON_REQUIRED_FIELDS (StartupConfig, startup_host_time, snapshot_tx_interval, initial_service_certificate_validity_days, service_subject_name, cose_signatures, service_data, node_data, start, join, recover, sealed_ledger_secret_location)
 
bool is_valid_actor (const std::string &actor)
 
constexpr auto get_actor_prefix (ActorsType at)
 
std::string get_combined_schema_name (const AllOfAuthnPolicy::Policies &policies)
 
std::shared_ptr<::http::HttpRpcContext > make_rpc_context (std::shared_ptr< ccf::SessionContext > s, const std::vector< uint8_t > &packed)
 
std::shared_ptr<::http::HttpRpcContext > make_fwd_rpc_context (std::shared_ptr< ccf::SessionContext > s, const std::vector< uint8_t > &packed, ccf::FrameFormat frame_format)
 
LedgerSecretPtr make_ledger_secret ()
 
std::vector< uint8_t > decrypt_previous_ledger_secret_raw (const LedgerSecretPtr &ledger_secret, const std::vector< uint8_t > &encrypted_previous_secret_raw)
 
std::string get_sealing_filename (const kv::Version &version)
 
std::optional< kv::Version > version_of_filename (const std::string &path)
 
crypto::GcmCipher aes_gcm_sealing (std::span< const uint8_t > raw_key, std::span< const uint8_t > plaintext, const std::span< uint8_t > &aad)
 
std::vector< uint8_t > aes_gcm_unsealing (std::span< const uint8_t > raw_key, const std::vector< uint8_t > &sealed_text, const std::span< uint8_t > &aad)
 
 DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS (SealedLedgerSecretAAD)
 
 DECLARE_JSON_REQUIRED_FIELDS (SealedLedgerSecretAAD)
 
 DECLARE_JSON_TYPE (SealedLedgerSecret)
 
 DECLARE_JSON_REQUIRED_FIELDS (SealedLedgerSecret, ciphertext, aad_text)
 
void seal_ledger_secret_to_disk (const std::string &sealed_secret_dir, const ccf::pal::snp::TcbVersionRaw &tcb_version, const kv::Version &version, const LedgerSecretPtr &ledger_secret)
 
std::optional< LedgerSecretPtr > unseal_ledger_secret_from_disk (ccf::kv::Version expected_version, const files::fs::path &ledger_secret_path)
 
LedgerSecretPtr find_and_unseal_ledger_secret_from_disk (const std::string &sealed_secret_dir, kv::Version max_version)
 
void reset_data (std::vector< uint8_t > &data)
 
bool verify_enclave_measurement_against_uvm_endorsements (ccf::kv::ReadOnlyTx &tx, const pal::PlatformAttestationMeasurement &quote_measurement, const std::vector< uint8_t > &uvm_endorsements)
 
QuoteVerificationResult verify_enclave_measurement_against_store (ccf::kv::ReadOnlyTx &tx, const pal::PlatformAttestationMeasurement &quote_measurement, const QuoteFormat &quote_format, const std::optional< std::vector< uint8_t > > &uvm_endorsements=std::nullopt)
 
QuoteVerificationResult verify_quoted_node_public_key (const std::vector< uint8_t > &expected_node_public_key, const ccf::crypto::Sha256Hash &quoted_hash)
 
QuoteVerificationResult verify_host_data_against_store (ccf::kv::ReadOnlyTx &tx, const QuoteInfo &quote_info)
 
std::optional< ccf::ClaimsDigest::Digest > __attribute__ ((weak)) get_create_tx_claims_digest(ccf
 
 DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS (Quote)
 
 DECLARE_JSON_REQUIRED_FIELDS (Quote, node_id, raw, endorsements, format)
 
 DECLARE_JSON_OPTIONAL_FIELDS (Quote, measurement, uvm_endorsements)
 
 DECLARE_JSON_TYPE_WITH_BASE (Attestation, Quote)
 
 DECLARE_JSON_REQUIRED_FIELDS (Attestation)
 
 DECLARE_JSON_TYPE (GetQuotes::Out)
 
 DECLARE_JSON_REQUIRED_FIELDS (GetQuotes::Out, quotes)
 
 DECLARE_JSON_TYPE (GetAttestations::Out)
 
 DECLARE_JSON_REQUIRED_FIELDS (GetAttestations::Out, attestations)
 
 DECLARE_JSON_TYPE (NodeMetrics)
 
 DECLARE_JSON_REQUIRED_FIELDS (NodeMetrics, sessions)
 
 DECLARE_JSON_TYPE (JavaScriptMetrics)
 
 DECLARE_JSON_REQUIRED_FIELDS (JavaScriptMetrics, bytecode_size, bytecode_used, max_heap_size, max_stack_size, max_execution_time, max_cached_interpreters)
 
 DECLARE_JSON_TYPE (SetJwtPublicSigningKeys)
 
 DECLARE_JSON_REQUIRED_FIELDS (SetJwtPublicSigningKeys, issuer, jwks)
 
 DECLARE_JSON_TYPE (ConsensusNodeConfig)
 
 DECLARE_JSON_REQUIRED_FIELDS (ConsensusNodeConfig, address)
 
 DECLARE_JSON_TYPE (ConsensusConfigDetails)
 
 DECLARE_JSON_REQUIRED_FIELDS (ConsensusConfigDetails, details)
 
 DECLARE_JSON_TYPE (SelfSignedNodeCertificateInfo)
 
 DECLARE_JSON_REQUIRED_FIELDS (SelfSignedNodeCertificateInfo, self_signed_certificate)
 
 DECLARE_JSON_TYPE (GetServicePreviousIdentity::Out)
 
 DECLARE_JSON_REQUIRED_FIELDS (GetServicePreviousIdentity::Out, previous_service_identity)
 
bool matches_uvm_roots_of_trust (const pal::UVMEndorsements &endorsements, const std::vector< pal::UVMEndorsements > &uvm_roots_of_trust)
 
pal::UVMEndorsements verify_uvm_endorsements (const std::vector< uint8_t > &uvm_endorsements_raw, const pal::PlatformAttestationMeasurement &uvm_measurement, const std::vector< pal::UVMEndorsements > &uvm_roots_of_trust, bool enforce_uvm_roots_of_trust)
 
pal::UVMEndorsements verify_uvm_endorsements_against_roots_of_trust (const std::vector< uint8_t > &uvm_endorsements_raw, const pal::PlatformAttestationMeasurement &uvm_measurement, const std::vector< pal::UVMEndorsements > &uvm_roots_of_trust)
 
 DECLARE_JSON_TYPE (UVMEndorsementsPayload)
 
 DECLARE_JSON_REQUIRED_FIELDS_WITH_RENAMES (UVMEndorsementsPayload, sevsnpvm_guest_svn, "x-ms-sevsnpvm-guestsvn", sevsnpvm_launch_measurement, "x-ms-sevsnpvm-launchmeasurement")
 
ccf::TxID previous_tx_if_recovery (ccf::TxID txid)
 
ccf::TxID next_tx_if_recovery (ccf::TxID txid)
 
std::shared_ptr< ccf::kv::Store > make_store ()
 
 DECLARE_JSON_OPTIONAL_FIELDS (ServiceConfiguration, consensus, reconfiguration_type, maximum_node_certificate_validity_days, maximum_service_certificate_validity_days, recent_cose_proposals_window_size) using Configuration
 
 DECLARE_JSON_TYPE (NodeSignature)
 
 DECLARE_JSON_REQUIRED_FIELDS (NodeSignature, sig, node, hashed_nonce)
 
 DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS (CoseEndorsement)
 
 DECLARE_JSON_REQUIRED_FIELDS (CoseEndorsement, endorsement, endorsement_epoch_begin, endorsing_key)
 
 DECLARE_JSON_OPTIONAL_FIELDS (CoseEndorsement, previous_version, endorsement_epoch_end)
 
 DECLARE_JSON_ENUM (RecoveryType, {{RecoveryType::NONE, "None"}, {RecoveryType::RECOVERY_SHARES, "RECOVERY_SHARES"}, {RecoveryType::LOCAL_UNSEALING, "LOCAL_UNSEALING"}})
 
 DECLARE_JSON_OPTIONAL_FIELDS (EncryptedLedgerSecret, previous_secret_stored_version) using EncryptedLedgerSecrets
 
 DECLARE_JSON_REQUIRED_FIELDS (RecoverySharesInfo, wrapped_latest_ledger_secret, encrypted_shares) DECLARE_JSON_OPTIONAL_FIELDS(RecoverySharesInfo
 
 DECLARE_JSON_REQUIRED_FIELDS (PreviousLedgerSecretInfo, encrypted_data, version) DECLARE_JSON_OPTIONAL_FIELDS(PreviousLedgerSecretInfo
 
 DECLARE_JSON_OPTIONAL_FIELDS (EncryptedLedgerSecretInfo, previous_ledger_secret, next_version) using RecoveryShares
 
 DECLARE_JSON_TYPE_WITH_BASE_AND_OPTIONAL_FIELDS (PrimarySignature, NodeSignature) DECLARE_JSON_REQUIRED_FIELDS(PrimarySignature
 
root DECLARE_JSON_OPTIONAL_FIELDS (PrimarySignature, cert)
 

Variables

constexpr View VIEW_UNKNOWN = 0
 
constexpr SeqNo SEQNO_UNKNOWN = 0
 
constexpr int MAX_HISTORY_LEN = 0
 
 seqno
 
 view
 
 commit_seqno
 
 commit_view
 

Detailed Description

Defines static instances of common framework-provided authentication policies, to be used freely by other apps.

Typedef Documentation

◆ ACMECertificates

using ccf::ACMECertificates = typedef ServiceMap<std::string, ccf::crypto::Pem>

◆ ApplicationProtocol

using ccf::ApplicationProtocol = typedef std::string

◆ AuthnPolicies

using ccf::AuthnPolicies = typedef std::vector<std::shared_ptr<AuthnPolicy> >

◆ ByteVector

using ccf::ByteVector = typedef llvm_vecsmall::SmallVector<uint8_t, 8>

◆ CACertBundlePEMs

using ccf::CACertBundlePEMs = typedef ServiceMap<std::string, std::string>

◆ Cert

using ccf::Cert = typedef std::vector<uint8_t>

◆ CodeIDs

using ccf::CodeIDs = typedef ServiceMap<pal::SgxAttestationMeasurement, CodeStatus>

◆ CommandHandlerWithJson

using ccf::CommandHandlerWithJson = typedef std::function<jsonhandler::JsonAdapterResponse( endpoints::CommandEndpointContext& ctx, nlohmann::json&& params)>

◆ ConsensusConfig

using ccf::ConsensusConfig = typedef std::map<std::string, ConsensusNodeConfig>

◆ Constitution

using ccf::Constitution = typedef ServiceValue<std::string>

◆ COSEGovernanceHistory

using ccf::COSEGovernanceHistory = typedef ServiceMap<MemberId, std::vector<uint8_t> >

◆ COSERecentProposals

using ccf::COSERecentProposals = typedef ServiceMap<std::string, ProposalId>

◆ CoseSignature

using ccf::CoseSignature = typedef std::vector<uint8_t>

◆ CoseSignatures

using ccf::CoseSignatures = typedef ServiceValue<CoseSignature>

◆ DID

using ccf::DID = typedef std::string

◆ DynamicEndpoints

using ccf::DynamicEndpoints = typedef ccf::ServiceMap<endpoints::EndpointKey, endpoints::EndpointProperties>

◆ EncryptedLedgerSecretsInfo

using ccf::EncryptedLedgerSecretsInfo = typedef ServiceValue<EncryptedLedgerSecretInfo>

◆ EncryptedShare

using ccf::EncryptedShare = typedef std::vector<uint8_t>

◆ EncryptedSharesMap

using ccf::EncryptedSharesMap = typedef std::map<MemberId, EncryptedShare>

◆ EncryptedSubmittedShare

using ccf::EncryptedSubmittedShare = typedef std::vector<uint8_t>

◆ EncryptedSubmittedShares

using ccf::EncryptedSubmittedShares = typedef ServiceMap<MemberId, EncryptedSubmittedShare>

◆ ExtendedState

using ccf::ExtendedState = typedef std::tuple< NodeStartupState, std::optional<ccf::kv::Version> , std::optional<ccf::kv::Version> >

◆ Feed

using ccf::Feed = typedef std::string

◆ FeedToEndorsementsDataMap

using ccf::FeedToEndorsementsDataMap = typedef std::map<Feed, UVMEndorsementsData>

◆ GcmHdr

using ccf::GcmHdr = typedef ccf::crypto::FixedSizeGcmHeader<sizeof(MsgNonce)>

◆ GovernanceHistory

using ccf::GovernanceHistory = typedef ServiceMap<MemberId, SignedReq>

◆ HandlerJsonParamsAndForward

using ccf::HandlerJsonParamsAndForward = typedef std::function<jsonhandler::JsonAdapterResponse( endpoints::EndpointContext& ctx, nlohmann::json&& params)>

◆ HistoryTree

using ccf::HistoryTree = typedef merkle::TreeT<sha256_byte_size, ccf::sha256_history>

◆ http_status

using ccf::http_status = typedef llhttp_status

◆ InterpreterFlush

using ccf::InterpreterFlush = typedef ServiceValue<bool>

◆ JSEngine

using ccf::JSEngine = typedef ServiceValue<JSRuntimeOptions>

◆ JwtIssuer

using ccf::JwtIssuer = typedef std::string

◆ JwtIssuers

using ccf::JwtIssuers = typedef ServiceMap<JwtIssuer, JwtIssuerMetadata>

◆ JwtKeyId

using ccf::JwtKeyId = typedef std::string

◆ JwtPublicSigningKeysMetadata

using ccf::JwtPublicSigningKeysMetadata = typedef ServiceMap<JwtKeyId, std::vector<OpenIDJWKMetadata> >

◆ JwtPublicSigningKeysMetadataLegacy

using ccf::JwtPublicSigningKeysMetadataLegacy = typedef ServiceMap<JwtKeyId, std::vector<OpenIDJWKMetadataLegacy> >

◆ LastRecoveryType

using ccf::LastRecoveryType = typedef ServiceValue<RecoveryType>

◆ LedgerSecretPtr

using ccf::LedgerSecretPtr = typedef std::shared_ptr<LedgerSecret>

◆ LedgerSecretsForNodes

using ccf::LedgerSecretsForNodes = typedef std::map<NodeId, EncryptedLedgerSecrets>

◆ LedgerSecretsMap

using ccf::LedgerSecretsMap = typedef std::map<ccf::kv::Version, LedgerSecretPtr>

◆ ListenInterfaceID

using ccf::ListenInterfaceID = typedef std::string

◆ MemberAcks

using ccf::MemberAcks = typedef ServiceMap<MemberId, MemberAck>

◆ MemberCerts

using ccf::MemberCerts = typedef ccf::kv::RawCopySerialisedMap<MemberId, ccf::crypto::Pem>

◆ MemberId

using ccf::MemberId = typedef EntityId<MemberIdFormatter>

◆ MemberInfo

using ccf::MemberInfo = typedef ServiceMap<MemberId, MemberDetails>

◆ MemberPublicEncryptionKeys

using ccf::MemberPublicEncryptionKeys = typedef ccf::kv::RawCopySerialisedMap<MemberId, ccf::crypto::Pem>

◆ MerkleTxHistory

using ccf::MerkleTxHistory = typedef HashedTxHistory<MerkleTreeHistory>

◆ Module

using ccf::Module = typedef std::string

◆ Modules

using ccf::Modules = typedef ccf::kv::RawCopySerialisedMap<std::string, Module>

◆ ModulesQuickJsBytecode

using ccf::ModulesQuickJsBytecode = typedef ccf::kv::RawCopySerialisedMap<std::string, std::vector<uint8_t> >

◆ ModulesQuickJsVersion

using ccf::ModulesQuickJsVersion = typedef ccf::kv::RawCopySerialisedValue<std::string>

◆ MsgNonce

using ccf::MsgNonce = typedef uint64_t

◆ NamedAuthPolicies

using ccf::NamedAuthPolicies = typedef std::unordered_map<std::string, std::shared_ptr<ccf::AuthnPolicy> >

◆ Node2NodeMsg

using ccf::Node2NodeMsg = typedef uint64_t

◆ NodeEncryptor

using ccf::NodeEncryptor = typedef ccf::kv::TxEncryptor<ccf::LedgerSecrets, TxGcmHeader>

◆ NodeEndorsedCertificates

using ccf::NodeEndorsedCertificates = typedef ccf::kv::RawCopySerialisedMap<NodeId, ccf::crypto::Pem>

◆ NodeId

using ccf::NodeId = typedef EntityId<NodeIdFormatter>

◆ Nodes

using ccf::Nodes = typedef ServiceMap<NodeId, NodeInfo>

◆ Nonce

using ccf::Nonce = typedef ccf::crypto::Sha256Hash

◆ OpenAPISecuritySchema

using ccf::OpenAPISecuritySchema = typedef std::pair<std::string, nlohmann::json>

◆ PathParams

using ccf::PathParams = typedef std::map<std::string, std::string, std::less<> >

◆ PreviousServiceIdentity

using ccf::PreviousServiceIdentity = typedef ServiceValue<ccf::crypto::Pem>

◆ PreviousServiceIdentityEndorsement

using ccf::PreviousServiceIdentityEndorsement = typedef ServiceValue<CoseEndorsement>

◆ PreviousServiceLastSignedRoot

using ccf::PreviousServiceLastSignedRoot = typedef ServiceValue<ccf::crypto::Sha256Hash>

◆ ProposalId

using ccf::ProposalId = typedef std::string

◆ PublicKey

using ccf::PublicKey = typedef std::vector<uint8_t>

◆ QUICSessionImpl

using ccf::QUICSessionImpl = typedef quic::QUICEchoSession

◆ QuoteEndorsementsFetchedCallback

using ccf::QuoteEndorsementsFetchedCallback = typedef std::function<void(std::vector<uint8_t>&& endorsements)>

◆ RaftType

using ccf::RaftType = typedef aft::Aft<::consensus::LedgerEnclave>

◆ ReadOnlyHandlerWithJson

using ccf::ReadOnlyHandlerWithJson = typedef std::function<jsonhandler::JsonAdapterResponse( endpoints::ReadOnlyEndpointContext& ctx, nlohmann::json&& params)>

◆ ReceiptPtr

using ccf::ReceiptPtr = typedef std::shared_ptr<Receipt>

◆ RecoveredEncryptedLedgerSecrets

using ccf::RecoveredEncryptedLedgerSecrets = typedef std::list<EncryptedLedgerSecretInfo>

◆ Secrets

using ccf::Secrets = typedef ServiceValue<LedgerSecretsForNodes>

◆ SeqNo

using ccf::SeqNo = typedef uint64_t

Each transaction is assigned a unique incrementing SeqNo, maintained across View transitions. This matches the order in which transactions are applied, where a higher SeqNo means that a transaction executed later. SeqNos are unique during normal operation, but around elections it is possible for distinct transactions in separate Views to have the same SeqNo. Only one of these transactions will ever commit, and the others are ephemeral.

◆ SeqNoCollection

using ccf::SeqNoCollection = typedef ccf::ds::ContiguousSet<ccf::SeqNo>

◆ SerialisedCoseEndorsement

using ccf::SerialisedCoseEndorsement = typedef std::vector<uint8_t>

◆ SerialisedCoseEndorsements

using ccf::SerialisedCoseEndorsements = typedef std::vector<SerialisedCoseEndorsement>

◆ SerialisedCoseSignature

using ccf::SerialisedCoseSignature = typedef std::vector<uint8_t>

◆ SerialisedMerkleTree

using ccf::SerialisedMerkleTree = typedef ccf::kv::RawCopySerialisedValue<std::vector<uint8_t> >

◆ Server

using ccf::Server = typedef pal::snp::EndorsementEndpointsConfiguration::Server

◆ Service

using ccf::Service = typedef ServiceValue<ServiceInfo>

◆ ServiceMap

template<typename K , typename V >
using ccf::ServiceMap = typedef ccf::kv::MapSerialisedWith< K, V, ccf::kv::serialisers::BlitSerialiser, ccf::kv::serialisers::JsonSerialiser>

◆ ServiceSet

template<typename K >
using ccf::ServiceSet = typedef ccf::kv::SetSerialisedWith< K, ccf::kv::serialisers::BlitSerialiser, ccf::kv::serialisers::ZeroBlitUnitCreator>

◆ ServiceValue

template<typename V >
using ccf::ServiceValue = typedef ccf::kv::ValueSerialisedWith< V, ccf::kv::serialisers::JsonSerialiser, ccf::kv::serialisers::ZeroBlitUnitCreator>

◆ Signatures

using ccf::Signatures = typedef ServiceValue<PrimarySignature>

◆ SnapshotEvidence

using ccf::SnapshotEvidence = typedef ServiceValue<SnapshotHash>

◆ SnpHostDataMap

using ccf::SnpHostDataMap = typedef ServiceMap<HostData, HostDataMetadata>

◆ SnpMeasurements

using ccf::SnpMeasurements = typedef ServiceMap<pal::SnpAttestationMeasurement, CodeStatus>

◆ SnpTcbVersionMap

using ccf::SnpTcbVersionMap = typedef ServiceMap<std::string, pal::snp::TcbVersionPolicy>

◆ SNPUVMEndorsements

using ccf::SNPUVMEndorsements = typedef ServiceMap<DID, FeedToEndorsementsDataMap>

◆ TxReceiptImplPtr

typedef std::shared_ptr< TxReceiptImpl > ccf::TxReceiptImplPtr

◆ UserCerts

using ccf::UserCerts = typedef ccf::kv::RawCopySerialisedMap<UserId, ccf::crypto::Pem>

◆ UserId

using ccf::UserId = typedef EntityId<UserIdFormatter>

◆ UserInfo

using ccf::UserInfo = typedef ServiceMap<UserId, UserDetails>

◆ VersionedLedgerSecret

using ccf::VersionedLedgerSecret = typedef LedgerSecretsMap::value_type

◆ View

using ccf::View = typedef uint64_t

Transactions occur within a fixed View. Each View generally spans a range of transactions, though empty Views are also possible. The View is advanced by the consensus protocol during election of a new leader, and a single leader is assigned in each View. View and Term are synonymous.

◆ VirtualHostDataMap

using ccf::VirtualHostDataMap = typedef ServiceSet<HostData>

◆ VirtualMeasurements

using ccf::VirtualMeasurements = typedef ServiceMap<pal::VirtualAttestationMeasurement, CodeStatus>

Enumeration Type Documentation

◆ anonymous enum

anonymous enum : ringbuffer::Message

Node-to-node related ringbuffer messages.

Enumerator
DEFINE_RINGBUFFER_MSG_TYPE 

Change the network nodes. Enclave -> Host.

Receive data from another node. Host -> Enclave Args are (msg_type, from_id, payload)

Send data to another node. Enclave -> Host Args are (to_id, msg_type, from_id, payload) The host may inspect the first 3, and should write the last 3 (to produce an equivalent node_inbound on the receiving node)

DEFINE_RINGBUFFER_MSG_TYPE 

Change the network nodes. Enclave -> Host.

Receive data from another node. Host -> Enclave Args are (msg_type, from_id, payload)

Send data to another node. Enclave -> Host Args are (to_id, msg_type, from_id, payload) The host may inspect the first 3, and should write the last 3 (to produce an equivalent node_inbound on the receiving node)

DEFINE_RINGBUFFER_MSG_TYPE 

Change the network nodes. Enclave -> Host.

Receive data from another node. Host -> Enclave Args are (msg_type, from_id, payload)

Send data to another node. Enclave -> Host Args are (to_id, msg_type, from_id, payload) The host may inspect the first 3, and should write the last 3 (to produce an equivalent node_inbound on the receiving node)

◆ ActionFormat

enum class ccf::ActionFormat
strong
Enumerator
COSE 
JSON 

◆ ActorsType

enum class ccf::ActorsType : uint64_t
strong
Enumerator
members 
users 
nodes 
acme_challenge 
unknown 

◆ ApiResult

enum class ccf::ApiResult
strong

Lists the possible return codes from the versioned APIs in ccf::BaseEndpointRegistry

Enumerator
OK 

Call was successful, results can be used

Uninitialised 

The node is not yet initialised, and doesn't have access to the service needed to answer this call. Should only be returned if the API is called too early, during node construction.

InvalidArgs 

One of the arguments passed to the function is invalid. It may be outside the range of known values, or not be in the expected format.

NotFound 

The requsted value was not found.

InternalError 

General error not covered by the cases above. Generally means that an unexpected exception was thrown during execution.

◆ Authority

enum class ccf::Authority
strong
Enumerator
NODE 
SERVICE 
ACME 
UNSECURED 

◆ ChannelMsg

enum ccf::ChannelMsg : Node2NodeMsg
Enumerator
key_exchange_init 
key_exchange_response 
key_exchange_final 

◆ ChannelStatus

enum ccf::ChannelStatus
Enumerator
INACTIVE 
INITIATED 
WAITING_FOR_FINAL 
ESTABLISHED 

◆ CodeStatus

enum class ccf::CodeStatus
strong
Enumerator
ALLOWED_TO_JOIN 

◆ ConsensusType

enum ccf::ConsensusType
Enumerator
CFT 
BFT 

◆ ForwardedMsg

enum ccf::ForwardedMsg : Node2NodeMsg
Enumerator
forwarded_cmd_v1 
forwarded_response_v1 
forwarded_cmd_v2 
forwarded_response_v2 
forwarded_cmd_v3 
forwarded_response_v3 

◆ FrameFormat

enum class ccf::FrameFormat : uint8_t
strong
Enumerator
http 

◆ HashOp

enum ccf::HashOp
Enumerator
APPEND 
VERIFY 
ROLLBACK 
COMPACT 

◆ HttpVersion

enum class ccf::HttpVersion
strong
Enumerator
HTTP1 
HTTP2 

◆ InvalidArgsReason

enum class ccf::InvalidArgsReason
strong

Lists possible reasons for an ApiResult::InvalidArgs being return in ccf::BaseEndpointRegistry

Enumerator
NoReason 
ViewSmallerThanOne 

Views start at 1 (one) in CCF

ActionAlreadyApplied 

Action has already been applied on this instance

StaleActionCreatedTimestamp 

Action created_at is older than the median of recent action

◆ JwtIssuerKeyFilter

enum class ccf::JwtIssuerKeyFilter
strong
Enumerator
All 

◆ LoggerLevel

enum ccf::LoggerLevel
Enumerator
TRACE 
DEBUG 
INFO 
FAIL 
FATAL 
MAX_LOG_LEVEL 

◆ MemberRecoveryRole

enum class ccf::MemberRecoveryRole
strong
Enumerator
NonParticipant 
Participant 
Owner 

If set then the member is to receive a key allowing it to single-handedly recover the network without requiring any other recovery member to submit their shares.

◆ MemberStatus

enum class ccf::MemberStatus
strong
Enumerator
ACCEPTED 
ACTIVE 

◆ MerkleProofLabel

enum ccf::MerkleProofLabel : int64_t
Enumerator
MERKLE_PROOF_LEAF_LABEL 
MERKLE_PROOF_PATH_LABEL 

◆ NodeMsgType

enum ccf::NodeMsgType : Node2NodeMsg
Enumerator
channel_msg 
consensus_msg 
forwarded_msg 

◆ NodeStartupState

enum class ccf::NodeStartupState
strong
Enumerator
uninitialized 
initialized 
pending 
partOfPublicNetwork 
partOfNetwork 
readingPublicLedger 
readingPrivateLedger 

◆ NodeStatus

enum class ccf::NodeStatus
strong
Enumerator
PENDING 
TRUSTED 
RETIRED 

◆ ProposalState

enum class ccf::ProposalState
strong

Members use proposals to propose changes to the public governance tables in the KV store. Active members can issue proposals. These proposals are stored in the KV, and passed to the JS constitution functions for validation and execution.

Enumerator
OPEN 
ACCEPTED 
WITHDRAWN 
REJECTED 
FAILED 
DROPPED 

◆ QuoteFormat

enum class ccf::QuoteFormat
strong
Enumerator
oe_sgx_v1 
insecure_virtual 
amd_sev_snp_v1 

◆ QuoteVerificationResult

enum class ccf::QuoteVerificationResult
strong
Enumerator
Verified 
Failed 
FailedMeasurementNotFound 
FailedHostDataDigestNotFound 
FailedInvalidHostData 
FailedInvalidQuotedPublicKey 
FailedUVMEndorsementsNotFound 
FailedInvalidCPUID 
FailedInvalidTcbVersion 

◆ ReconfigurationType

enum ccf::ReconfigurationType
Enumerator
ONE_TRANSACTION 
TWO_TRANSACTION 

◆ RecoveryType

enum ccf::RecoveryType
Enumerator
NONE 
RECOVERY_SHARES 
LOCAL_UNSEALING 

◆ RedirectionResolutionKind

enum class ccf::RedirectionResolutionKind
strong
Enumerator
NodeByRole 
StaticAddress 

◆ ServiceStatus

enum class ccf::ServiceStatus
strong
Enumerator
OPENING 
OPEN 
WAITING_FOR_RECOVERY_SHARES 
RECOVERING 

◆ SessionStatus

enum ccf::SessionStatus
Enumerator
handshake 
ready 
closing 
closed 
authfail 
error 

◆ TxStatus

enum class ccf::TxStatus
strong

Describes the status of a transaction, as seen by this node.

Enumerator
Unknown 

This node has not received this transaction, and knows nothing about it

Pending 

This node has this transaction locally, but has not yet heard that the transaction has been committed by the distributed consensus

Committed 

This node has seen that this transaction is committed, it is an irrevocable and durable part of the service's transaction history

Invalid 

This node knows that the given transaction cannot be committed. This may mean there has been a view change, and a previously pending transaction has been lost (the original request should be resubmitted and will be given a new Transaction ID). This also describes IDs which are known to be impossible given the currently committed IDs

Function Documentation

◆ __attribute__()

std::optional< ccf::ClaimsDigest::Digest > ccf::__attribute__ ( (weak)  )

◆ add_schema_components() [1/3]

template<typename T >
void ccf::add_schema_components ( T &  helper,
nlohmann::json &  schema,
const ProofReceipt::Components *  comp 
)

◆ add_schema_components() [2/3]

template<typename T >
void ccf::add_schema_components ( T &  helper,
nlohmann::json &  schema,
const ProofReceipt::ProofStep *  ps 
)

◆ add_schema_components() [3/3]

template<typename T >
void ccf::add_schema_components ( T &  helper,
nlohmann::json &  schema,
const ReceiptPtr *  r 
)

◆ aes_gcm_sealing()

crypto::GcmCipher ccf::aes_gcm_sealing ( std::span< const uint8_t >  raw_key,
std::span< const uint8_t >  plaintext,
const std::span< uint8_t > &  aad 
)
inline

◆ aes_gcm_unsealing()

std::vector< uint8_t > ccf::aes_gcm_unsealing ( std::span< const uint8_t >  raw_key,
const std::vector< uint8_t > &  sealed_text,
const std::span< uint8_t > &  aad 
)
inline

◆ api_result_to_str()

constexpr char const * ccf::api_result_to_str ( ApiResult  result)
constexpr

◆ compute_node_id_from_cert_der()

NodeId ccf::compute_node_id_from_cert_der ( const std::vector< uint8_t > &  node_cert_der)
inline

◆ compute_node_id_from_kp()

NodeId ccf::compute_node_id_from_kp ( const ccf::crypto::KeyPairPtr &  node_sign_kp)
inline

◆ compute_node_id_from_pubk_der()

NodeId ccf::compute_node_id_from_pubk_der ( const std::vector< uint8_t > &  node_pubk_der)
inline

◆ DECLARE_JSON_ENUM() [1/14]

ccf::DECLARE_JSON_ENUM ( ActionFormat  ,
{{ActionFormat::COSE, "COSE"}, {ActionFormat::JSON, "JSON"}}   
)

◆ DECLARE_JSON_ENUM() [2/14]

ccf::DECLARE_JSON_ENUM ( Authority  ,
{{Authority::NODE, "Node"}, {Authority::SERVICE, "Service"}, {Authority::ACME, "ACME"}, {Authority::UNSECURED, "Unsecured"}}   
)

◆ DECLARE_JSON_ENUM() [3/14]

ccf::DECLARE_JSON_ENUM ( CodeStatus  ,
{{CodeStatus::ALLOWED_TO_JOIN, "AllowedToJoin"}}   
)

◆ DECLARE_JSON_ENUM() [4/14]

ccf::DECLARE_JSON_ENUM ( JwtIssuerKeyFilter  ,
{{JwtIssuerKeyFilter::All, "all"}}   
)

◆ DECLARE_JSON_ENUM() [5/14]

ccf::DECLARE_JSON_ENUM ( LoggerLevel  ,
{{LoggerLevel::TRACE, "Trace"}, {LoggerLevel::DEBUG, "Debug"}, {LoggerLevel::INFO, "Info"}, {LoggerLevel::FAIL, "Fail"}, {LoggerLevel::FATAL, "Fatal"}}   
)

◆ DECLARE_JSON_ENUM() [6/14]

ccf::DECLARE_JSON_ENUM ( MemberRecoveryRole  ,
{{MemberRecoveryRole::NonParticipant, "NonParticipant"}, {MemberRecoveryRole::Participant, "Participant"}, {MemberRecoveryRole::Owner, "Owner"}}   
)

◆ DECLARE_JSON_ENUM() [7/14]

ccf::DECLARE_JSON_ENUM ( MemberStatus  ,
{{MemberStatus::ACCEPTED, "Accepted"}, {MemberStatus::ACTIVE, "Active"}}   
)

◆ DECLARE_JSON_ENUM() [8/14]

ccf::DECLARE_JSON_ENUM ( NodeStatus  ,
{{NodeStatus::PENDING, "Pending"}, {NodeStatus::TRUSTED, "Trusted"}, {NodeStatus::RETIRED, "Retired"}}   
)

◆ DECLARE_JSON_ENUM() [9/14]

ccf::DECLARE_JSON_ENUM ( ProposalState  ,
{{ProposalState::OPEN, "Open"}, {ProposalState::ACCEPTED, "Accepted"}, {ProposalState::WITHDRAWN, "Withdrawn"}, {ProposalState::REJECTED, "Rejected"}, {ProposalState::FAILED, "Failed"}, {ProposalState::DROPPED, "Dropped"}}   
)

◆ DECLARE_JSON_ENUM() [10/14]

ccf::DECLARE_JSON_ENUM ( QuoteFormat  ,
{{QuoteFormat::oe_sgx_v1, "OE_SGX_v1"}, {QuoteFormat::insecure_virtual, "Insecure_Virtual"}, {QuoteFormat::amd_sev_snp_v1, "AMD_SEV_SNP_v1"}}   
)

◆ DECLARE_JSON_ENUM() [11/14]

ccf::DECLARE_JSON_ENUM ( RecoveryType  ,
{{RecoveryType::NONE, "None"}, {RecoveryType::RECOVERY_SHARES, "RECOVERY_SHARES"}, {RecoveryType::LOCAL_UNSEALING, "LOCAL_UNSEALING"}}   
)

◆ DECLARE_JSON_ENUM() [12/14]

ccf::DECLARE_JSON_ENUM ( RedirectionResolutionKind  ,
{{RedirectionResolutionKind::NodeByRole, "NodeByRole"}, {RedirectionResolutionKind::StaticAddress, "StaticAddress"}}   
)

◆ DECLARE_JSON_ENUM() [13/14]

ccf::DECLARE_JSON_ENUM ( ServiceStatus  ,
{{ServiceStatus::OPENING, "Opening"}, {ServiceStatus::OPEN, "Open"}, {ServiceStatus::WAITING_FOR_RECOVERY_SHARES, "WaitingForRecoveryShares"}, {ServiceStatus::RECOVERING, "Recovering"}}   
)

◆ DECLARE_JSON_ENUM() [14/14]

ccf::DECLARE_JSON_ENUM ( TxStatus  ,
{{TxStatus::Unknown, tx_status_to_str(TxStatus::Unknown)}, {TxStatus::Pending, tx_status_to_str(TxStatus::Pending)}, {TxStatus::Committed, tx_status_to_str(TxStatus::Committed)}, {TxStatus::Invalid, tx_status_to_str(TxStatus::Invalid)}}   
)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [1/29]

ccf::DECLARE_JSON_OPTIONAL_FIELDS ( ACMEClientConfig  ,
not_before  ,
not_after  ,
challenge_server_interface   
)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [2/29]

ccf::DECLARE_JSON_OPTIONAL_FIELDS ( CCFConfig  ,
worker_threads  ,
node_certificate  ,
consensus  ,
ledger  ,
ledger_signatures  ,
jwt  ,
attestation  ,
snapshots  ,
node_to_node_message_limit  ,
historical_cache_soft_limit   
)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [3/29]

ccf::DECLARE_JSON_OPTIONAL_FIELDS ( CCFConfig::Attestation  ,
snp_endorsements_servers  ,
environment  ,
snp_security_policy_file  ,
snp_uvm_endorsements_file  ,
snp_endorsements_file   
)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [4/29]

ccf::DECLARE_JSON_OPTIONAL_FIELDS ( CCFConfig::Attestation::Environment  ,
security_policy  ,
uvm_endorsements  ,
snp_endorsements   
)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [5/29]

ccf::DECLARE_JSON_OPTIONAL_FIELDS ( CCFConfig::JWT  ,
key_refresh_interval   
)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [6/29]

ccf::DECLARE_JSON_OPTIONAL_FIELDS ( CCFConfig::Ledger  ,
directory  ,
read_only_directories  ,
chunk_size   
)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [7/29]

ccf::DECLARE_JSON_OPTIONAL_FIELDS ( CCFConfig::LedgerSignatures  ,
tx_count  ,
delay   
)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [8/29]

ccf::DECLARE_JSON_OPTIONAL_FIELDS ( CCFConfig::NodeCertificateInfo  ,
subject_name  ,
subject_alt_names  ,
curve_id  ,
initial_validity_days   
)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [9/29]

ccf::DECLARE_JSON_OPTIONAL_FIELDS ( CCFConfig::Snapshots  ,
directory  ,
tx_count  ,
read_only_directory   
)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [10/29]

ccf::DECLARE_JSON_OPTIONAL_FIELDS ( CoseEndorsement  ,
previous_version  ,
endorsement_epoch_end   
)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [11/29]

ccf::DECLARE_JSON_OPTIONAL_FIELDS ( EncryptedLedgerSecret  ,
previous_secret_stored_version   
)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [12/29]

ccf::DECLARE_JSON_OPTIONAL_FIELDS ( EncryptedLedgerSecretInfo  ,
previous_ledger_secret  ,
next_version   
)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [13/29]

ccf::DECLARE_JSON_OPTIONAL_FIELDS ( Endorsement  ,
acme_configuration   
)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [14/29]

ccf::DECLARE_JSON_OPTIONAL_FIELDS ( JwtIssuerMetadata  ,
ca_cert_bundle_name  ,
auto_refresh   
)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [15/29]

ccf::DECLARE_JSON_OPTIONAL_FIELDS ( NewMember  ,
encryption_pub_key  ,
member_data  ,
recovery_role   
)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [16/29]

ccf::DECLARE_JSON_OPTIONAL_FIELDS ( NodeInfo  ,
cert  ,
ledger_secret_seqno  ,
code_digest  ,
certificate_signing_request  ,
public_key  ,
node_data  ,
retired_committed   
)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [17/29]

ccf::DECLARE_JSON_OPTIONAL_FIELDS ( NodeInfoNetwork_v2  ,
acme  ,
will_locally_seal_ledger_secrets   
)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [18/29]

ccf::DECLARE_JSON_OPTIONAL_FIELDS ( NodeInfoNetwork_v2::NetInterface  ,
endorsement  ,
max_open_sessions_soft  ,
max_open_sessions_hard  ,
published_address  ,
protocol  ,
app_protocol  ,
http_configuration  ,
accepted_endpoints  ,
forwarding_timeout_ms  ,
redirections   
)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [19/29]

ccf::DECLARE_JSON_OPTIONAL_FIELDS ( NodeInfoNetwork_v2::NetInterface::Redirections  ,
to_primary  ,
to_backup   
)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [20/29]

ccf::DECLARE_JSON_OPTIONAL_FIELDS ( ODataError  ,
details   
)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [21/29]

ccf::DECLARE_JSON_OPTIONAL_FIELDS ( ODataJSExceptionDetails  ,
trace   
)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [22/29]

ccf::DECLARE_JSON_OPTIONAL_FIELDS ( OpenIDJWKMetadata  ,
constraint   
)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [23/29]

ccf::DECLARE_JSON_OPTIONAL_FIELDS ( OpenIDJWKMetadataLegacy  ,
constraint   
)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [24/29]

root ccf::DECLARE_JSON_OPTIONAL_FIELDS ( PrimarySignature  ,
cert   
)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [25/29]

ccf::DECLARE_JSON_OPTIONAL_FIELDS ( Quote  ,
measurement  ,
uvm_endorsements   
)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [26/29]

ccf::DECLARE_JSON_OPTIONAL_FIELDS ( QuoteInfo  ,
uvm_endorsements  ,
endorsed_tcb   
)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [27/29]

ccf::DECLARE_JSON_OPTIONAL_FIELDS ( RedirectionResolverConfig  ,
target   
)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [28/29]

ccf::DECLARE_JSON_OPTIONAL_FIELDS ( ServiceConfiguration  ,
consensus  ,
reconfiguration_type  ,
maximum_node_certificate_validity_days  ,
maximum_service_certificate_validity_days  ,
recent_cose_proposals_window_size   
)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [29/29]

ccf::DECLARE_JSON_OPTIONAL_FIELDS ( ServiceInfo  ,
previous_service_identity_version  ,
recovery_count  ,
service_data  ,
current_service_create_txid   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [1/48]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( ACMEClientConfig  ,
ca_certs  ,
directory_url  ,
service_dns_name  ,
contact  ,
terms_of_service_agreed  ,
challenge_type   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [2/48]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( Attestation  )

◆ DECLARE_JSON_REQUIRED_FIELDS() [3/48]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( CCFConfig  ,
network   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [4/48]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( CCFConfig::Attestation  )

◆ DECLARE_JSON_REQUIRED_FIELDS() [5/48]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( CCFConfig::Attestation::Environment  )

◆ DECLARE_JSON_REQUIRED_FIELDS() [6/48]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( CCFConfig::JWT  )

◆ DECLARE_JSON_REQUIRED_FIELDS() [7/48]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( CCFConfig::Ledger  )

◆ DECLARE_JSON_REQUIRED_FIELDS() [8/48]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( CCFConfig::LedgerSignatures  )

◆ DECLARE_JSON_REQUIRED_FIELDS() [9/48]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( CCFConfig::Snapshots  )

◆ DECLARE_JSON_REQUIRED_FIELDS() [10/48]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( ConsensusConfigDetails  ,
details   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [11/48]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( ConsensusNodeConfig  ,
address   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [12/48]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( CoseEndorsement  ,
endorsement  ,
endorsement_epoch_begin  ,
endorsing_key   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [13/48]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( COSESignaturesConfig  ,
issuer  ,
subject   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [14/48]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( Endorsement  ,
authority   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [15/48]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( GetAttestations::Out  ,
attestations   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [16/48]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( GetQuotes::Out  ,
quotes   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [17/48]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( GetServicePreviousIdentity::Out  ,
previous_service_identity   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [18/48]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( JavaScriptMetrics  ,
bytecode_size  ,
bytecode_used  ,
max_heap_size  ,
max_stack_size  ,
max_execution_time  ,
max_cached_interpreters   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [19/48]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( JwtIssuerMetadata  )

◆ DECLARE_JSON_REQUIRED_FIELDS() [20/48]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( NodeInfo  ,
quote_info  ,
encryption_pub_key  ,
status   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [21/48]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( NodeInfoNetwork_v1  ,
rpchost  ,
pubhost  ,
nodehost  ,
nodeport  ,
rpcport  ,
pubport   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [22/48]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( NodeInfoNetwork_v2  ,
node_to_node_interface  ,
rpc_interfaces   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [23/48]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( NodeInfoNetwork_v2::ACME  ,
configurations   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [24/48]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( NodeInfoNetwork_v2::NetInterface  ,
bind_address   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [25/48]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( NodeInfoNetwork_v2::NetInterface::Redirections  )

◆ DECLARE_JSON_REQUIRED_FIELDS() [26/48]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( NodeMetrics  ,
sessions   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [27/48]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( NodeSignature  ,
sig  ,
node  ,
hashed_nonce   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [28/48]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( ODataAuthErrorDetails  ,
auth_policy  ,
code  ,
message   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [29/48]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( ODataError  ,
code  ,
message   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [30/48]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( ODataErrorResponse  ,
error   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [31/48]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( ODataJSExceptionDetails  ,
code  ,
message   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [32/48]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( OpenIDJWKMetadata  ,
issuer  ,
public_key   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [33/48]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( OpenIDJWKMetadataLegacy  ,
issuer  ,
cert   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [34/48]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( PreviousLedgerSecretInfo  ,
encrypted_data  ,
version   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [35/48]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( Quote  ,
node_id  ,
raw  ,
endorsements  ,
format   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [36/48]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( QuoteInfo  ,
format  ,
quote  ,
endorsements   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [37/48]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( RecoverySharesInfo  ,
wrapped_latest_ledger_secret  ,
encrypted_shares   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [38/48]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( RedirectionResolverConfig  ,
kind   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [39/48]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( SealedLedgerSecret  ,
ciphertext  ,
aad_text   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [40/48]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( SealedLedgerSecretAAD  )

◆ DECLARE_JSON_REQUIRED_FIELDS() [41/48]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( SelfSignedNodeCertificateInfo  ,
self_signed_certificate   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [42/48]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( ServiceInfo  ,
cert  ,
status   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [43/48]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( SetJwtPublicSigningKeys  ,
issuer  ,
jwks   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [44/48]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( StartupConfig  ,
startup_host_time  ,
snapshot_tx_interval  ,
initial_service_certificate_validity_days  ,
service_subject_name  ,
cose_signatures  ,
service_data  ,
node_data  ,
start  ,
join  ,
recover  ,
sealed_ledger_secret_location   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [45/48]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( StartupConfig::Join  ,
target_rpc_address  ,
retry_timeout  ,
service_cert  ,
follow_redirect   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [46/48]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( StartupConfig::Recover  ,
previous_service_identity  ,
previous_sealed_ledger_secret_location   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [47/48]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( StartupConfig::Start  ,
members  ,
constitution  ,
service_configuration   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [48/48]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( UVMEndorsementsData  ,
svn   
)

◆ DECLARE_JSON_REQUIRED_FIELDS_WITH_RENAMES()

ccf::DECLARE_JSON_REQUIRED_FIELDS_WITH_RENAMES ( UVMEndorsementsPayload  ,
sevsnpvm_guest_svn  ,
"x-ms-sevsnpvm-guestsvn"  ,
sevsnpvm_launch_measurement  ,
"x-ms-sevsnpvm-launchmeasurement"   
)

◆ DECLARE_JSON_TYPE() [1/22]

ccf::DECLARE_JSON_TYPE ( ACMEClientConfig  )

◆ DECLARE_JSON_TYPE() [2/22]

ccf::DECLARE_JSON_TYPE ( ConsensusConfigDetails  )

◆ DECLARE_JSON_TYPE() [3/22]

ccf::DECLARE_JSON_TYPE ( ConsensusNodeConfig  )

◆ DECLARE_JSON_TYPE() [4/22]

ccf::DECLARE_JSON_TYPE ( COSESignaturesConfig  )

◆ DECLARE_JSON_TYPE() [5/22]

ccf::DECLARE_JSON_TYPE ( GetAttestations::Out  )

◆ DECLARE_JSON_TYPE() [6/22]

ccf::DECLARE_JSON_TYPE ( GetQuotes::Out  )

◆ DECLARE_JSON_TYPE() [7/22]

ccf::DECLARE_JSON_TYPE ( GetServicePreviousIdentity::Out  )

◆ DECLARE_JSON_TYPE() [8/22]

ccf::DECLARE_JSON_TYPE ( JavaScriptMetrics  )

◆ DECLARE_JSON_TYPE() [9/22]

ccf::DECLARE_JSON_TYPE ( NodeInfoNetwork_v1  )

◆ DECLARE_JSON_TYPE() [10/22]

ccf::DECLARE_JSON_TYPE ( NodeInfoNetwork_v2::ACME  )

◆ DECLARE_JSON_TYPE() [11/22]

ccf::DECLARE_JSON_TYPE ( NodeMetrics  )

◆ DECLARE_JSON_TYPE() [12/22]

ccf::DECLARE_JSON_TYPE ( NodeSignature  )

◆ DECLARE_JSON_TYPE() [13/22]

ccf::DECLARE_JSON_TYPE ( ODataAuthErrorDetails  )

◆ DECLARE_JSON_TYPE() [14/22]

ccf::DECLARE_JSON_TYPE ( ODataErrorResponse  )

◆ DECLARE_JSON_TYPE() [15/22]

ccf::DECLARE_JSON_TYPE ( SealedLedgerSecret  )

◆ DECLARE_JSON_TYPE() [16/22]

ccf::DECLARE_JSON_TYPE ( SelfSignedNodeCertificateInfo  )

◆ DECLARE_JSON_TYPE() [17/22]

ccf::DECLARE_JSON_TYPE ( SetJwtPublicSigningKeys  )

◆ DECLARE_JSON_TYPE() [18/22]

ccf::DECLARE_JSON_TYPE ( StartupConfig::Join  )

◆ DECLARE_JSON_TYPE() [19/22]

ccf::DECLARE_JSON_TYPE ( StartupConfig::Recover  )

◆ DECLARE_JSON_TYPE() [20/22]

ccf::DECLARE_JSON_TYPE ( StartupConfig::Start  )

◆ DECLARE_JSON_TYPE() [21/22]

ccf::DECLARE_JSON_TYPE ( UVMEndorsementsData  )

◆ DECLARE_JSON_TYPE() [22/22]

ccf::DECLARE_JSON_TYPE ( UVMEndorsementsPayload  )

◆ DECLARE_JSON_TYPE_WITH_BASE() [1/2]

ccf::DECLARE_JSON_TYPE_WITH_BASE ( Attestation  ,
Quote   
)

◆ DECLARE_JSON_TYPE_WITH_BASE() [2/2]

ccf::DECLARE_JSON_TYPE_WITH_BASE ( StartupConfig  ,
CCFConfig   
)

◆ DECLARE_JSON_TYPE_WITH_BASE_AND_OPTIONAL_FIELDS() [1/2]

ccf::DECLARE_JSON_TYPE_WITH_BASE_AND_OPTIONAL_FIELDS ( NodeInfo  ,
NodeInfoNetwork   
)

◆ DECLARE_JSON_TYPE_WITH_BASE_AND_OPTIONAL_FIELDS() [2/2]

ccf::DECLARE_JSON_TYPE_WITH_BASE_AND_OPTIONAL_FIELDS ( PrimarySignature  ,
NodeSignature   
)

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [1/23]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( CCFConfig  )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [2/23]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( CCFConfig::Attestation  )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [3/23]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( CCFConfig::Attestation::Environment  )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [4/23]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( CCFConfig::JWT  )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [5/23]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( CCFConfig::Ledger  )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [6/23]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( CCFConfig::LedgerSignatures  )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [7/23]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( CCFConfig::NodeCertificateInfo  )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [8/23]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( CCFConfig::Snapshots  )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [9/23]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( CoseEndorsement  )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [10/23]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( Endorsement  )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [11/23]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( JwtIssuerMetadata  )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [12/23]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( NodeInfoNetwork_v2  )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [13/23]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( NodeInfoNetwork_v2::NetInterface  )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [14/23]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( NodeInfoNetwork_v2::NetInterface::Redirections  )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [15/23]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( ODataError  )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [16/23]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( ODataJSExceptionDetails  )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [17/23]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( OpenIDJWKMetadata  )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [18/23]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( OpenIDJWKMetadataLegacy  )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [19/23]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( Quote  )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [20/23]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( QuoteInfo  )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [21/23]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( RedirectionResolverConfig  )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [22/23]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( SealedLedgerSecretAAD  )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [23/23]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( ServiceInfo  )

◆ decrypt_previous_ledger_secret_raw()

std::vector< uint8_t > ccf::decrypt_previous_ledger_secret_raw ( const LedgerSecretPtr &  ledger_secret,
const std::vector< uint8_t > &  encrypted_previous_secret_raw 
)
inline

◆ describe_cose_endorsements_v1()

std::optional< SerialisedCoseEndorsements > ccf::describe_cose_endorsements_v1 ( const TxReceiptImpl &  receipt)

◆ describe_cose_signature_v1()

std::optional< SerialisedCoseSignature > ccf::describe_cose_signature_v1 ( const TxReceiptImpl &  receipt)

◆ describe_merkle_proof_v1()

std::optional< std::vector< uint8_t > > ccf::describe_merkle_proof_v1 ( const TxReceiptImpl &  receipt)

◆ describe_receipt_v1()

nlohmann::json ccf::describe_receipt_v1 ( const TxReceiptImpl &  receipt)

◆ describe_receipt_v2()

ccf::ReceiptPtr ccf::describe_receipt_v2 ( const TxReceiptImpl &  in)

◆ fill_json_schema() [1/8]

void ccf::fill_json_schema ( nlohmann::json &  schema,
const ClaimsDigest *   
)
inline

◆ fill_json_schema() [2/8]

template<typename FmtExtender >
void ccf::fill_json_schema ( nlohmann::json &  schema,
const EntityId< FmtExtender > *   
)
inline

◆ fill_json_schema() [3/8]

void ccf::fill_json_schema ( nlohmann::json &  schema,
const JSRuntimeOptions *   
)
inline

◆ fill_json_schema() [4/8]

void ccf::fill_json_schema ( nlohmann::json &  schema,
const ProofReceipt::Components *  components 
)

◆ fill_json_schema() [5/8]

void ccf::fill_json_schema ( nlohmann::json &  schema,
const ProofReceipt::ProofStep *  step 
)

◆ fill_json_schema() [6/8]

void ccf::fill_json_schema ( nlohmann::json &  schema,
const ReceiptPtr *  receipt 
)

◆ fill_json_schema() [7/8]

void ccf::fill_json_schema ( nlohmann::json &  schema,
const RESTVerb *   
)
inline

◆ fill_json_schema() [8/8]

void ccf::fill_json_schema ( nlohmann::json &  schema,
const TxID *   
)
inline

◆ find_and_unseal_ledger_secret_from_disk()

LedgerSecretPtr ccf::find_and_unseal_ledger_secret_from_disk ( const std::string &  sealed_secret_dir,
kv::Version  max_version 
)
inline

◆ from_json() [1/9]

void ccf::from_json ( const nlohmann::json &  j,
ClaimsDigest &  hash 
)
inline

◆ from_json() [2/9]

template<typename FmtExtender >
void ccf::from_json ( const nlohmann::json &  j,
EntityId< FmtExtender > &  entity_id 
)
inline

◆ from_json() [3/9]

void ccf::from_json ( const nlohmann::json &  j,
JSRuntimeOptions &  options 
)
inline

◆ from_json() [4/9]

void ccf::from_json ( const nlohmann::json &  j,
NodeInfoNetwork &  nin 
)
inline

◆ from_json() [5/9]

void ccf::from_json ( const nlohmann::json &  j,
ProofReceipt::Components &  components 
)

◆ from_json() [6/9]

void ccf::from_json ( const nlohmann::json &  j,
ProofReceipt::ProofStep &  step 
)

◆ from_json() [7/9]

void ccf::from_json ( const nlohmann::json &  j,
ReceiptPtr &  receipt 
)

◆ from_json() [8/9]

void ccf::from_json ( const nlohmann::json &  j,
RESTVerb &  verb 
)
inline

◆ from_json() [9/9]

void ccf::from_json ( const nlohmann::json &  j,
TxID &  tx_id 
)
inline

◆ get_actor_prefix()

constexpr auto ccf::get_actor_prefix ( ActorsType  at)
constexpr

◆ get_combined_schema_name()

std::string ccf::get_combined_schema_name ( const AllOfAuthnPolicy::Policies &  policies)

◆ get_create_tx_claims_digest()

std::optional< ccf::ClaimsDigest::Digest > ccf::get_create_tx_claims_digest ( ccf::kv::ReadOnlyTx &  tx)

Can be optionally implemented by the application to set the claims digest for the initial network create transaction.

Returns
an optional claims digest

◆ get_sealing_filename()

std::string ccf::get_sealing_filename ( const kv::Version &  version)
inline

◆ invalid_args_reason_to_str()

constexpr char const * ccf::invalid_args_reason_to_str ( InvalidArgsReason  reason)
constexpr

◆ is_valid_actor()

bool ccf::is_valid_actor ( const std::string &  actor)
inline

◆ json_adapter()

endpoints::EndpointFunction ccf::json_adapter ( const HandlerJsonParamsAndForward &  f)

◆ json_command_adapter()

endpoints::CommandEndpointFunction ccf::json_command_adapter ( const CommandHandlerWithJson &  f)

◆ json_read_only_adapter()

endpoints::ReadOnlyEndpointFunction ccf::json_read_only_adapter ( const ReadOnlyHandlerWithJson &  f)

◆ make_error()

jsonhandler::JsonAdapterResponse ccf::make_error ( ccf::http_status  status,
const std::string &  code,
const std::string &  msg 
)

◆ make_fwd_rpc_context()

std::shared_ptr<::http::HttpRpcContext > ccf::make_fwd_rpc_context ( std::shared_ptr< ccf::SessionContext >  s,
const std::vector< uint8_t > &  packed,
ccf::FrameFormat  frame_format 
)
inline

◆ make_ledger_secret()

LedgerSecretPtr ccf::make_ledger_secret ( )
inline

◆ make_redirect()

jsonhandler::JsonAdapterResponse ccf::make_redirect ( ccf::http_status  status)

◆ make_rpc_context()

std::shared_ptr<::http::HttpRpcContext > ccf::make_rpc_context ( std::shared_ptr< ccf::SessionContext >  s,
const std::vector< uint8_t > &  packed 
)
inline

◆ make_store()

std::shared_ptr< ccf::kv::Store > ccf::make_store ( )
inline

◆ make_success() [1/3]

jsonhandler::JsonAdapterResponse ccf::make_success ( )

◆ make_success() [2/3]

jsonhandler::JsonAdapterResponse ccf::make_success ( const nlohmann::json &  result_payload)

◆ make_success() [3/3]

jsonhandler::JsonAdapterResponse ccf::make_success ( nlohmann::json &&  result_payload)

◆ make_user_endpoints()

std::unique_ptr< ccf::endpoints::EndpointRegistry > ccf::make_user_endpoints ( ccf::AbstractNodeContext &  context)

To be implemented by the application. Creates a collection of endpoints which will be exposed to callers under /app.

Parameters
contextAccess to node and host services
Returns
Unique pointer to the endpoint registry instance

◆ matches_uvm_roots_of_trust()

bool ccf::matches_uvm_roots_of_trust ( const pal::UVMEndorsements &  endorsements,
const std::vector< pal::UVMEndorsements > &  uvm_roots_of_trust 
)
inline

◆ next_tx_if_recovery()

ccf::TxID ccf::next_tx_if_recovery ( ccf::TxID  txid)

◆ previous_tx_if_recovery()

ccf::TxID ccf::previous_tx_if_recovery ( ccf::TxID  txid)

◆ reset_data()

void ccf::reset_data ( std::vector< uint8_t > &  data)

◆ run()

int ccf::run ( int  argc,
char **  argv 
)

◆ schema_name() [1/8]

std::string ccf::schema_name ( const ClaimsDigest *  )
inline

◆ schema_name() [2/8]

template<typename FmtExtender >
std::string ccf::schema_name ( const EntityId< FmtExtender > *  )
inline

◆ schema_name() [3/8]

std::string ccf::schema_name ( const JSRuntimeOptions *  )
inline

◆ schema_name() [4/8]

std::string ccf::schema_name ( const ProofReceipt::Components *  components)

◆ schema_name() [5/8]

std::string ccf::schema_name ( const ProofReceipt::ProofStep *  step)

◆ schema_name() [6/8]

std::string ccf::schema_name ( const ReceiptPtr *  receipt)

◆ schema_name() [7/8]

std::string ccf::schema_name ( const RESTVerb *  )
inline

◆ schema_name() [8/8]

std::string ccf::schema_name ( const TxID *  )
inline

◆ seal_ledger_secret_to_disk()

void ccf::seal_ledger_secret_to_disk ( const std::string &  sealed_secret_dir,
const ccf::pal::snp::TcbVersionRaw &  tcb_version,
const kv::Version &  version,
const LedgerSecretPtr &  ledger_secret 
)
inline

◆ to_json() [1/9]

void ccf::to_json ( nlohmann::json &  j,
const ClaimsDigest &  hash 
)
inline

◆ to_json() [2/9]

template<typename FmtExtender >
void ccf::to_json ( nlohmann::json &  j,
const EntityId< FmtExtender > &  entity_id 
)
inline

◆ to_json() [3/9]

void ccf::to_json ( nlohmann::json &  j,
const JSRuntimeOptions &  options 
)
inline

◆ to_json() [4/9]

void ccf::to_json ( nlohmann::json &  j,
const NodeInfoNetwork &  nin 
)
inline

◆ to_json() [5/9]

void ccf::to_json ( nlohmann::json &  j,
const ProofReceipt::Components &  components 
)

◆ to_json() [6/9]

void ccf::to_json ( nlohmann::json &  j,
const ProofReceipt::ProofStep &  step 
)

◆ to_json() [7/9]

void ccf::to_json ( nlohmann::json &  j,
const ReceiptPtr &  receipt 
)

◆ to_json() [8/9]

void ccf::to_json ( nlohmann::json &  j,
const RESTVerb &  verb 
)
inline

◆ to_json() [9/9]

void ccf::to_json ( nlohmann::json &  j,
const TxID &  tx_id 
)
inline

◆ tx_status_to_str()

constexpr char const * ccf::tx_status_to_str ( TxStatus  status)
constexpr

◆ unseal_ledger_secret_from_disk()

std::optional< LedgerSecretPtr > ccf::unseal_ledger_secret_from_disk ( ccf::kv::Version  expected_version,
const files::fs::path &  ledger_secret_path 
)
inline

◆ validate_issuer()

bool ccf::validate_issuer ( const std::string &  iss,
const std::optional< std::string > &  tid,
std::string  constraint 
)

◆ verify_enclave_measurement_against_store()

QuoteVerificationResult ccf::verify_enclave_measurement_against_store ( ccf::kv::ReadOnlyTx &  tx,
const pal::PlatformAttestationMeasurement &  quote_measurement,
const QuoteFormat &  quote_format,
const std::optional< std::vector< uint8_t > > &  uvm_endorsements = std::nullopt 
)

◆ verify_enclave_measurement_against_uvm_endorsements()

bool ccf::verify_enclave_measurement_against_uvm_endorsements ( ccf::kv::ReadOnlyTx &  tx,
const pal::PlatformAttestationMeasurement &  quote_measurement,
const std::vector< uint8_t > &  uvm_endorsements 
)

◆ verify_host_data_against_store()

QuoteVerificationResult ccf::verify_host_data_against_store ( ccf::kv::ReadOnlyTx &  tx,
const QuoteInfo &  quote_info 
)

◆ verify_quoted_node_public_key()

QuoteVerificationResult ccf::verify_quoted_node_public_key ( const std::vector< uint8_t > &  expected_node_public_key,
const ccf::crypto::Sha256Hash &  quoted_hash 
)

◆ verify_tcb_version_against_store()

QuoteVerificationResult ccf::verify_tcb_version_against_store ( ccf::kv::ReadOnlyTx &  tx,
const QuoteInfo &  quote_info 
)

◆ verify_uvm_endorsements()

pal::UVMEndorsements ccf::verify_uvm_endorsements ( const std::vector< uint8_t > &  uvm_endorsements_raw,
const pal::PlatformAttestationMeasurement &  uvm_measurement,
const std::vector< pal::UVMEndorsements > &  uvm_roots_of_trust,
bool  enforce_uvm_roots_of_trust 
)

◆ verify_uvm_endorsements_against_roots_of_trust()

pal::UVMEndorsements ccf::verify_uvm_endorsements_against_roots_of_trust ( const std::vector< uint8_t > &  uvm_endorsements_raw,
const pal::PlatformAttestationMeasurement &  uvm_measurement,
const std::vector< pal::UVMEndorsements > &  uvm_roots_of_trust 
)

◆ version_of_filename()

std::optional< kv::Version > ccf::version_of_filename ( const std::string &  path)
inline

Variable Documentation

◆ commit_seqno

ccf::commit_seqno

◆ commit_view

ccf::commit_view

◆ MAX_HISTORY_LEN

constexpr int ccf::MAX_HISTORY_LEN = 0
constexpr

◆ seqno

ccf::seqno

◆ SEQNO_UNKNOWN

constexpr SeqNo ccf::SEQNO_UNKNOWN = 0
constexpr

◆ view

ccf::view

◆ VIEW_UNKNOWN

constexpr View ccf::VIEW_UNKNOWN = 0
constexpr
Generated by doxygen 1.9.8