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

Namespaces

namespace  consensus
 
namespace  cose
 
namespace  crypto
 
namespace  did
 
namespace  ds
 
namespace  enclavetime
 
namespace  endpoints
 
namespace  env
 
namespace  errors
 
namespace  gov
 
namespace  grpc
 
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  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
 
class  AttestationProvider
 
struct  AuditInfo
 
struct  AuthnIdentity
 
class  AuthnPolicy
 
struct  BackupSignatures
 
class  BaseEndpointRegistry
 
class  ccf_logic_error
 
class  ccf_oe_attester_init_error
 
class  ccf_oe_verifier_init_error
 
class  ccf_openssl_rdrand_init_error
 
class  Channel
 
struct  ChannelHeader
 
class  ClaimsDigest
 
class  ClientSession
 
class  CommonEndpointRegistry
 
class  ConfigurationChangeHook
 
struct  ConsensusConfigDetails
 
struct  ConsensusNodeConfig
 
struct  COSESign1AuthnIdentity
 
struct  CreateNetworkNodeToNode
 
class  CustomProtocolSubsystem
 
class  CustomProtocolSubsystemInterface
 
struct  EmptyAuthnIdentity
 
class  EmptyAuthnPolicy
 
class  Enclave
 
struct  EncryptedLedgerSecret
 
struct  EncryptedLedgerSecretInfo
 
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  FullMemberDetails
 
struct  GetAPI
 
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  JsBundle
 
struct  JsBundleMetadata
 
class  JSHandlers
 
struct  JsonField
 
class  JsonParseError
 
struct  JsonWebKeySet
 
struct  JSRuntimeOptions
 
struct  JwtAuthnIdentity
 
class  JwtAuthnPolicy
 
struct  JwtIssuerKeyPolicy
 
struct  JwtIssuerMetadata
 
class  JwtKeyAutoRefresh
 
struct  JWTRefreshMetrics
 
class  KeyExchangeProtocol
 
struct  KeyIdInfo
 
struct  LedgerSecret
 
class  LedgerSecrets
 
class  LedgerSecretsBroadcast
 
class  LedgerSecretWrappingKey
 
struct  MemberAck
 
struct  MemberCertAuthnIdentity
 
class  MemberCertAuthnPolicy
 
struct  MemberCOSESign1AuthnIdentity
 
class  MemberCOSESign1AuthnPolicy
 
struct  MemberDetails
 
class  MemberEndpoints
 
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  PreviousLedgerSecretInfo
 
struct  PrimarySignature
 
class  Proof
 
class  ProofReceipt
 
struct  ProtectedHeader
 
struct  Quote
 
class  QuoteEndorsementsClient
 
struct  QuoteInfo
 Describes a quote (attestation) from trusted hardware. More...
 
class  Receipt
 
struct  RecoverySharesInfo
 
struct  RedirectDetails
 
struct  RedirectionResolverConfig
 
class  ReplicatedNetworkIdentity
 
class  RESTVerb
 
class  RetiredNodeCleanup
 
class  RingbufferLogger
 
class  RpcContext
 Describes the currently executing RPC. More...
 
class  RpcContextImpl
 
struct  RpcException
 
class  RpcFrontend
 
class  RpcHandler
 
class  RPCMap
 
class  RPCSessions
 
class  SecretSharing
 
struct  SelfSignedNodeCertificateInfo
 
struct  ServiceConfiguration
 
struct  ServiceInfo
 
class  Session
 
struct  SessionContext
 
struct  SessionMetrics
 
struct  SetJwtPublicSigningKeys
 
struct  SetModule
 
class  ShareManager
 
class  SignatureReceipt
 
struct  SignedReq
 
struct  SnapshotHash
 
class  Snapshotter
 
struct  StartupSnapshotInfo
 
struct  StateDigest
 
struct  SubmitRecoveryShare
 
class  ThreadedSession
 
struct  TimestampedProtectedHeader
 
class  TLSSession
 
class  TpccHandlers
 
struct  TxGcmHeader
 
struct  TxID
 
struct  TxReceiptImpl
 
class  TypedUserCOSESign1AuthnPolicy
 
struct  UserCertAuthnIdentity
 
class  UserCertAuthnPolicy
 
struct  UserCOSESign1AuthnIdentity
 
class  UserCOSESign1AuthnPolicy
 
struct  UserDetails
 
class  UserEndpointRegistry
 
struct  UserIdFormatter
 
class  UserRpcFrontend
 
struct  UVMEndorsements
 
struct  UVMEndorsementsData
 
struct  UvmEndorsementsProtectedHeader
 
struct  ValidityPeriodsCache
 
struct  VerifiersCache
 
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 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 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 JSEngine = ServiceValue< JSRuntimeOptions >
 
using JwtIssuer = std::string
 
using JwtKeyId = std::string
 
using Cert = std::vector< uint8_t >
 
using JwtIssuers = ServiceMap< JwtIssuer, JwtIssuerMetadata >
 
using JwtPublicSigningKeys = ServiceMap< JwtKeyId, std::vector< OpenIDJWKMetadata > >
 
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 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 View = uint64_t
 
using SeqNo = uint64_t
 
using QUICSessionImpl = quic::QUICEchoSession
 
template<typename In , typename Out >
using GrpcEndpoint = std::function< grpc::GrpcAdapterResponse< Out >(endpoints::EndpointContext &, In &&)>
 
template<typename In , typename Out >
using GrpcReadOnlyEndpoint = std::function< grpc::GrpcAdapterResponse< Out >(endpoints::ReadOnlyEndpointContext &, In &&)>
 
template<typename In , typename Out >
using GrpcCommandEndpoint = std::function< grpc::GrpcAdapterResponse< Out >(endpoints::CommandEndpointContext &, In &&)>
 
template<typename In , typename Out >
using GrpcCommandUnaryStreamEndpoint = std::function< grpc::GrpcAdapterStreamingResponse(endpoints::CommandEndpointContext &, In &&, grpc::StreamPtr< Out > &&)>
 
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 JsBundleEndpoint = std::map< std::string, ccf::endpoints::EndpointProperties >
 
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 BackupSignaturesMap = ServiceValue< BackupSignatures >
 
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 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 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
}
 
enum class  NodeStartupState {
  uninitialized , initialized , pending , partOfPublicNetwork ,
  partOfNetwork , readingPublicLedger , readingPrivateLedger
}
 
enum class  CodeStatus { ALLOWED_TO_JOIN = 0 }
 
enum class  NodeStatus { PENDING = 0 , TRUSTED = 1 , RETIRED = 2 }
 
enum class  Authority { NODE , SERVICE , ACME , UNSECURED }
 
enum class  RedirectionResolutionKind { NodeByRole , StaticAddress }
 
enum class  JwtIssuerKeyFilter { All , SGX }
 
enum class  MemberStatus { ACCEPTED = 0 , ACTIVE = 1 }
 
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 class  IdentityType { REPLICATED , SPLIT }
 
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  ProposalSubmissionStatus { Acceptable , DuplicateInWindow , TooOld }
 
enum class  HttpVersion { HTTP1 = 0 , HTTP2 }
 

Functions

std::unique_ptr< ccf::endpoints::EndpointRegistry > make_user_endpoints (ccf::AbstractNodeContext &context)
 
std::vector< ccf::js::FFIPlugin > get_js_plugins ()
 
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 (http_status status, const std::string &code, const std::string &msg)
 
jsonhandler::JsonAdapterResponse make_redirect (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 (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 &receipt)
 
void to_json (nlohmann::json &j, const ProofReceipt::Components &step)
 
void from_json (const nlohmann::json &j, ProofReceipt::Components &step)
 
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)
 
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 *)
 
 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)
 
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_TYPE (JwtIssuerKeyPolicy)
 
 DECLARE_JSON_REQUIRED_FIELDS (JwtIssuerKeyPolicy, sgx_claims)
 
 DECLARE_JSON_ENUM (JwtIssuerKeyFilter, {{JwtIssuerKeyFilter::All, "all"}, {JwtIssuerKeyFilter::SGX, "sgx"}})
 
 DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS (JwtIssuerMetadata)
 
 DECLARE_JSON_REQUIRED_FIELDS (JwtIssuerMetadata, key_filter)
 
 DECLARE_JSON_OPTIONAL_FIELDS (JwtIssuerMetadata, key_policy, ca_cert_bundle_name, auto_refresh)
 
 DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS (OpenIDJWKMetadata)
 
 DECLARE_JSON_REQUIRED_FIELDS (OpenIDJWKMetadata, cert, issuer)
 
 DECLARE_JSON_OPTIONAL_FIELDS (OpenIDJWKMetadata, constraint)
 
 DECLARE_JSON_ENUM (MemberStatus, {{MemberStatus::ACCEPTED, "Accepted"}, {MemberStatus::ACTIVE, "Active"}})
 
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)}})
 
std::unique_ptr< ccf::endpoints::EndpointRegistry > make_user_endpoints_impl (ccf::AbstractNodeContext &context)
 
bool is_valid_actor (const std::string &actor)
 
constexpr auto get_actor_prefix (ActorsType at)
 
void initialize_verifiers ()
 
void shutdown_verifiers ()
 
std::string get_combined_schema_name (const AllOfAuthnPolicy::Policies &policies)
 
template<typename In , typename Out >
endpoints::EndpointFunction grpc_adapter (const GrpcEndpoint< In, Out > &f)
 
template<typename In , typename Out >
endpoints::ReadOnlyEndpointFunction grpc_read_only_adapter (const GrpcReadOnlyEndpoint< In, Out > &f)
 
template<typename In , typename Out >
endpoints::CommandEndpointFunction grpc_command_adapter (const GrpcCommandEndpoint< In, Out > &f)
 
template<typename In , typename Out >
endpoints::CommandEndpointFunction grpc_command_unary_stream_adapter (const GrpcCommandUnaryStreamEndpoint< In, Out > &f)
 
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)
 
std::vector< ccf::js::FFIPlugin > __attribute__ ((weak)) get_js_plugins()
 
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)
 
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)
 
 DECLARE_JSON_TYPE (FullMemberDetails)
 
 DECLARE_JSON_REQUIRED_FIELDS (FullMemberDetails, status, member_data, cert, public_encryption_key)
 
 DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS (Quote)
 
 DECLARE_JSON_REQUIRED_FIELDS (Quote, node_id, raw, endorsements, format)
 
 DECLARE_JSON_OPTIONAL_FIELDS (Quote, mrenclave, uvm_endorsements)
 
 DECLARE_JSON_TYPE (GetQuotes::Out)
 
 DECLARE_JSON_REQUIRED_FIELDS (GetQuotes::Out, quotes)
 
 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)
 
 DECLARE_JSON_TYPE (UVMEndorsements)
 
 DECLARE_JSON_REQUIRED_FIELDS (UVMEndorsements, did, feed, svn)
 
bool matches_uvm_roots_of_trust (const UVMEndorsements &endorsements, const std::vector< UVMEndorsements > &uvm_roots_of_trust)
 
std::shared_ptr< ccf::kv::Store > make_store ()
 
 DECLARE_JSON_TYPE (BackupSignatures)
 
 DECLARE_JSON_REQUIRED_FIELDS (BackupSignatures, view, seqno, root, signatures)
 
 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_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)
 
std::optional< ccf::ClaimsDigest::Digest > get_create_tx_claims_digest (ccf::kv::ReadOnlyTx &tx)
 

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> >

◆ BackupSignaturesMap

using ccf::BackupSignaturesMap = typedef ServiceValue<BackupSignatures>

◆ 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>

◆ GrpcCommandEndpoint

template<typename In , typename Out >
using ccf::GrpcCommandEndpoint = typedef std::function<grpc::GrpcAdapterResponse<Out>( endpoints::CommandEndpointContext&, In&&)>

◆ GrpcCommandUnaryStreamEndpoint

template<typename In , typename Out >
using ccf::GrpcCommandUnaryStreamEndpoint = typedef std::function<grpc::GrpcAdapterStreamingResponse( endpoints::CommandEndpointContext&, In&&, grpc::StreamPtr<Out>&&)>

◆ GrpcEndpoint

template<typename In , typename Out >
using ccf::GrpcEndpoint = typedef std::function<grpc::GrpcAdapterResponse<Out>( endpoints::EndpointContext&, In&&)>

◆ GrpcReadOnlyEndpoint

template<typename In , typename Out >
using ccf::GrpcReadOnlyEndpoint = typedef std::function<grpc::GrpcAdapterResponse<Out>( endpoints::ReadOnlyEndpointContext&, In&&)>

◆ 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>

◆ InterpreterFlush

using ccf::InterpreterFlush = typedef ServiceValue<bool>

◆ JsBundleEndpoint

using ccf::JsBundleEndpoint = typedef std::map<std::string, ccf::endpoints::EndpointProperties>

◆ 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

◆ JwtPublicSigningKeys

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

◆ 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>

◆ ProposalId

using ccf::ProposalId = typedef std::string

◆ 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>

◆ SerialisedMerkleTree

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

◆ 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>

◆ 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.

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 

◆ 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 

◆ IdentityType

enum class ccf::IdentityType
strong
Enumerator
REPLICATED 
SPLIT 

◆ 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 
SGX 

◆ MemberStatus

enum class ccf::MemberStatus
strong
Enumerator
ACCEPTED 
ACTIVE 

◆ 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 

◆ ProposalSubmissionStatus

enum class ccf::ProposalSubmissionStatus
strong
Enumerator
Acceptable 
DuplicateInWindow 
TooOld 

◆ 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 

◆ 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 
)

◆ 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/11]

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

◆ DECLARE_JSON_ENUM() [2/11]

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

◆ DECLARE_JSON_ENUM() [3/11]

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

◆ DECLARE_JSON_ENUM() [4/11]

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

◆ DECLARE_JSON_ENUM() [5/11]

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

◆ DECLARE_JSON_ENUM() [6/11]

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

◆ DECLARE_JSON_ENUM() [7/11]

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() [8/11]

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() [9/11]

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

◆ DECLARE_JSON_ENUM() [10/11]

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

◆ DECLARE_JSON_ENUM() [11/11]

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/18]

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

◆ DECLARE_JSON_OPTIONAL_FIELDS() [2/18]

ccf::DECLARE_JSON_OPTIONAL_FIELDS ( EncryptedLedgerSecret  ,
previous_secret_stored_version   
)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [3/18]

ccf::DECLARE_JSON_OPTIONAL_FIELDS ( EncryptedLedgerSecretInfo  ,
previous_ledger_secret  ,
next_version   
)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [4/18]

ccf::DECLARE_JSON_OPTIONAL_FIELDS ( Endorsement  ,
acme_configuration   
)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [5/18]

ccf::DECLARE_JSON_OPTIONAL_FIELDS ( JwtIssuerMetadata  ,
key_policy  ,
ca_cert_bundle_name  ,
auto_refresh   
)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [6/18]

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() [7/18]

ccf::DECLARE_JSON_OPTIONAL_FIELDS ( NodeInfoNetwork_v2  ,
acme   
)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [8/18]

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() [9/18]

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

◆ DECLARE_JSON_OPTIONAL_FIELDS() [10/18]

ccf::DECLARE_JSON_OPTIONAL_FIELDS ( ODataError  ,
details   
)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [11/18]

ccf::DECLARE_JSON_OPTIONAL_FIELDS ( ODataJSExceptionDetails  ,
trace   
)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [12/18]

ccf::DECLARE_JSON_OPTIONAL_FIELDS ( OpenIDJWKMetadata  ,
constraint   
)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [13/18]

root ccf::DECLARE_JSON_OPTIONAL_FIELDS ( PrimarySignature  ,
cert   
)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [14/18]

ccf::DECLARE_JSON_OPTIONAL_FIELDS ( Quote  ,
mrenclave  ,
uvm_endorsements   
)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [15/18]

ccf::DECLARE_JSON_OPTIONAL_FIELDS ( QuoteInfo  ,
uvm_endorsements  ,
endorsed_tcb   
)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [16/18]

ccf::DECLARE_JSON_OPTIONAL_FIELDS ( RedirectionResolverConfig  ,
target   
)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [17/18]

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() [18/18]

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

◆ DECLARE_JSON_REQUIRED_FIELDS() [1/34]

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/34]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( BackupSignatures  ,
view  ,
seqno  ,
root  ,
signatures   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [3/34]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( ConsensusConfigDetails  ,
details   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [4/34]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( ConsensusNodeConfig  ,
address   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [5/34]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( Endorsement  ,
authority   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [6/34]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( FullMemberDetails  ,
status  ,
member_data  ,
cert  ,
public_encryption_key   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [7/34]

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

◆ DECLARE_JSON_REQUIRED_FIELDS() [8/34]

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

◆ DECLARE_JSON_REQUIRED_FIELDS() [9/34]

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() [10/34]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( JwtIssuerKeyPolicy  ,
sgx_claims   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [11/34]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( JwtIssuerMetadata  ,
key_filter   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [12/34]

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

◆ DECLARE_JSON_REQUIRED_FIELDS() [13/34]

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

◆ DECLARE_JSON_REQUIRED_FIELDS() [14/34]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( NodeInfoNetwork_v2  ,
node_to_node_interface  ,
rpc_interfaces   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [15/34]

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

◆ DECLARE_JSON_REQUIRED_FIELDS() [16/34]

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

◆ DECLARE_JSON_REQUIRED_FIELDS() [17/34]

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

◆ DECLARE_JSON_REQUIRED_FIELDS() [18/34]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( NodeMetrics  ,
sessions   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [19/34]

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

◆ DECLARE_JSON_REQUIRED_FIELDS() [20/34]

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

◆ DECLARE_JSON_REQUIRED_FIELDS() [21/34]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( ODataError  ,
code  ,
message   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [22/34]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( ODataErrorResponse  ,
error   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [23/34]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( ODataJSExceptionDetails  ,
code  ,
message   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [24/34]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( OpenIDJWKMetadata  ,
cert  ,
issuer   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [25/34]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( PreviousLedgerSecretInfo  ,
encrypted_data  ,
version   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [26/34]

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

◆ DECLARE_JSON_REQUIRED_FIELDS() [27/34]

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

◆ DECLARE_JSON_REQUIRED_FIELDS() [28/34]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( RecoverySharesInfo  ,
wrapped_latest_ledger_secret  ,
encrypted_shares   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [29/34]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( RedirectionResolverConfig  ,
kind   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [30/34]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( SelfSignedNodeCertificateInfo  ,
self_signed_certificate   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [31/34]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( ServiceInfo  ,
cert  ,
status   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [32/34]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( SetJwtPublicSigningKeys  ,
issuer  ,
jwks   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [33/34]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( UVMEndorsements  ,
did  ,
feed  ,
svn   
)

◆ DECLARE_JSON_REQUIRED_FIELDS() [34/34]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( UVMEndorsementsData  ,
svn   
)

◆ DECLARE_JSON_TYPE() [1/19]

ccf::DECLARE_JSON_TYPE ( ACMEClientConfig  )

◆ DECLARE_JSON_TYPE() [2/19]

ccf::DECLARE_JSON_TYPE ( BackupSignatures  )

◆ DECLARE_JSON_TYPE() [3/19]

ccf::DECLARE_JSON_TYPE ( ConsensusConfigDetails  )

◆ DECLARE_JSON_TYPE() [4/19]

ccf::DECLARE_JSON_TYPE ( ConsensusNodeConfig  )

◆ DECLARE_JSON_TYPE() [5/19]

ccf::DECLARE_JSON_TYPE ( FullMemberDetails  )

◆ DECLARE_JSON_TYPE() [6/19]

ccf::DECLARE_JSON_TYPE ( GetQuotes::Out  )

◆ DECLARE_JSON_TYPE() [7/19]

ccf::DECLARE_JSON_TYPE ( GetServicePreviousIdentity::Out  )

◆ DECLARE_JSON_TYPE() [8/19]

ccf::DECLARE_JSON_TYPE ( JavaScriptMetrics  )

◆ DECLARE_JSON_TYPE() [9/19]

ccf::DECLARE_JSON_TYPE ( JwtIssuerKeyPolicy  )

◆ DECLARE_JSON_TYPE() [10/19]

ccf::DECLARE_JSON_TYPE ( NodeInfoNetwork_v1  )

◆ DECLARE_JSON_TYPE() [11/19]

ccf::DECLARE_JSON_TYPE ( NodeInfoNetwork_v2::ACME  )

◆ DECLARE_JSON_TYPE() [12/19]

ccf::DECLARE_JSON_TYPE ( NodeMetrics  )

◆ DECLARE_JSON_TYPE() [13/19]

ccf::DECLARE_JSON_TYPE ( NodeSignature  )

◆ DECLARE_JSON_TYPE() [14/19]

ccf::DECLARE_JSON_TYPE ( ODataAuthErrorDetails  )

◆ DECLARE_JSON_TYPE() [15/19]

ccf::DECLARE_JSON_TYPE ( ODataErrorResponse  )

◆ DECLARE_JSON_TYPE() [16/19]

ccf::DECLARE_JSON_TYPE ( SelfSignedNodeCertificateInfo  )

◆ DECLARE_JSON_TYPE() [17/19]

ccf::DECLARE_JSON_TYPE ( SetJwtPublicSigningKeys  )

◆ DECLARE_JSON_TYPE() [18/19]

ccf::DECLARE_JSON_TYPE ( UVMEndorsements  )

◆ DECLARE_JSON_TYPE() [19/19]

ccf::DECLARE_JSON_TYPE ( UVMEndorsementsData  )

◆ 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/12]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( Endorsement  )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [2/12]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( JwtIssuerMetadata  )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [3/12]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( NodeInfoNetwork_v2  )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [4/12]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( NodeInfoNetwork_v2::NetInterface  )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [5/12]

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

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [6/12]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( ODataError  )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [7/12]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( ODataJSExceptionDetails  )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [8/12]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( OpenIDJWKMetadata  )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [9/12]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( Quote  )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [10/12]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( QuoteInfo  )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [11/12]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( RedirectionResolverConfig  )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [12/12]

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_receipt_v1()

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

◆ describe_receipt_v2()

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

◆ 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 *   
)

◆ fill_json_schema() [5/8]

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

◆ fill_json_schema() [6/8]

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

◆ 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

◆ 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 &  step 
)

◆ 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)

◆ get_js_plugins()

std::vector< ccf::js::FFIPlugin > ccf::get_js_plugins ( )

To be implemented by the application.

Returns
Vector of JavaScript FFI plugins

◆ grpc_adapter()

template<typename In , typename Out >
endpoints::EndpointFunction ccf::grpc_adapter ( const GrpcEndpoint< In, Out > &  f)

◆ grpc_command_adapter()

template<typename In , typename Out >
endpoints::CommandEndpointFunction ccf::grpc_command_adapter ( const GrpcCommandEndpoint< In, Out > &  f)

◆ grpc_command_unary_stream_adapter()

template<typename In , typename Out >
endpoints::CommandEndpointFunction ccf::grpc_command_unary_stream_adapter ( const GrpcCommandUnaryStreamEndpoint< In, Out > &  f)

◆ grpc_read_only_adapter()

template<typename In , typename Out >
endpoints::ReadOnlyEndpointFunction ccf::grpc_read_only_adapter ( const GrpcReadOnlyEndpoint< In, Out > &  f)

◆ initialize_verifiers()

void ccf::initialize_verifiers ( )

◆ 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 ( 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 ( 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

◆ make_user_endpoints_impl()

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

◆ matches_uvm_roots_of_trust()

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

◆ reset_data()

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

◆ 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 *  )

◆ schema_name() [5/8]

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

◆ schema_name() [6/8]

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

◆ schema_name() [7/8]

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

◆ schema_name() [8/8]

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

◆ shutdown_verifiers()

void ccf::shutdown_verifiers ( )

◆ 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 &  step 
)

◆ 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

◆ 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 
)

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