Namespaces
namespace	cbor

namespace	consensus

namespace	cose

namespace	crypto

namespace	curl

namespace	cwt

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	jwt_management_detail

namespace	kv

namespace	logger

namespace	node

namespace	nonstd

namespace	pal

namespace	policy

namespace	recovery_decision_protocol

namespace	samples

namespace	sealing

namespace	sealing_recovery

namespace	siphash

namespace	Tables

namespace	tasks

namespace	threading

namespace	tls

Classes
class	AbstractCOSESignaturesConfigSubsystem

class	AbstractForwarder

class	AbstractGovernanceEffects

struct	AbstractNodeContext

class	AbstractNodeOperation

class	AbstractNodeState

class	AbstractNodeSubSystem

class	AbstractReadLedgerSubsystemInterface

class	AbstractRPCResponder

class	ActiveMemberCOSESign1AuthnPolicy

struct	AllOfAuthnIdentity

class	AllOfAuthnPolicy

struct	AnyCertAuthnIdentity

class	AnyCertAuthnPolicy

struct	Attestation

class	AttestationProvider

struct	AuditInfo

struct	AuthnIdentity

class	AuthnPolicy

class	BaseEndpointRegistry

struct	CachedSignature

struct	CCFConfig

class	Channel

struct	ChannelHeader

class	ClaimsDigest

class	ClientSession

class	CommitCallbackInterface

class	CommitCallbackSubsystem

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	GetHistoricalCacheInfo

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	HTTPNodeClient

struct	IdentityHistoryNotFetched

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

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	ReadLedgerSubsystem

class	Receipt

class	ReconstructedLedgerSecretWrappingKey

struct	RecoveryDecisionProtocolConfig

class	RecoveryDecisionProtocolSubsystem

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	SealedRecoveryKey

struct	SealedSharesInfo

struct	SealingRecoveryConfig

struct	SelfSignedNodeCertificateInfo

struct	ServiceConfiguration

struct	ServiceInfo

class	Session

struct	SessionContext

struct	SessionMetrics

struct	SetJwtPublicSigningKeys

class	SharedLedgerSecretWrappingKey

class	ShareManager

class	SignatureCacheInterface

class	SignatureCacheSubsystem

class	SignatureReceipt

struct	SignedReq

struct	SnapshotHash

struct	SnapshotSegments

struct	SnapshotStatus

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	UvmEndorsementsProtectedHeader

struct	ValidityPeriodsCache

struct	VerifyReceipt

struct	WireNonce

struct	WriterFactories

Concepts
concept	SubsystemType

Typedefs
using	ByteVector = llvm_vecsmall::SmallVector< uint8_t, CHAR_BIT >

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	RawCoseEndorsement = std::vector< uint8_t >
	A single raw COSE endorsement, stored as an opaque byte vector.

using	CoseEndorsementsChain = std::vector< RawCoseEndorsement >
	An ordered chain of raw COSE endorsements.

using	TrustedKeys = std::map< ccf::SeqNo, ccf::crypto::ECPublicKeyPtr >

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	SerialisedCoseReceipt = std::vector< uint8_t >

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	ServiceUnit = ccf::kv::UnitValue< ccf::kv::serialisers::ZeroBlitUnitCreator >

using	ApplicationProtocol = std::string

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	ECPublicKey = 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	CodeUpdatePolicy = ccf::kv::RawCopySerialisedValue< std::string >

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	CommitCallback = std::function< void(ccf::TxID, ccf::FinalTxStatus)>

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	Configuration = ServiceValue< ServiceConfiguration >

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	EncryptedSealedSharesMap = std::map< NodeId, EncryptedShare >

using	SealedShares = ServiceValue< SealedSharesInfo >

using	SealedRecoveryKeys = ServiceMap< NodeId, ccf::SealedRecoveryKey >

using	LocalSealingNodeIdMap = ServiceMap< sealing_recovery::Name, NodeId >

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	EncryptedLedgerSecrets = std::vector< EncryptedLedgerSecret >

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

using	Secrets = ServiceValue< LedgerSecretsForNodes >

using	EncryptedShare = std::vector< uint8_t >

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

using	RecoveryShares = ServiceValue< RecoverySharesInfo >

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	SnapshotStatusValue = ServiceValue< SnapshotStatus >

using	SnapshotCreate = ServiceUnit

using	EncryptedSubmittedShare = std::vector< uint8_t >

using	EncryptedSubmittedShares = ServiceMap< MemberId, EncryptedSubmittedShare >

Enumerations
enum class	ApiResult : uint8_t { OK = 0 , Uninitialised , InvalidArgs , NotFound , InternalError }

enum class	InvalidArgsReason : uint8_t { NoReason = 0 , ViewSmallerThanOne , ActionAlreadyApplied , StaleActionCreatedTimestamp }

enum class	LoggerLevel : uint8_t { TRACE , DEBUG , INFO , FAIL , FATAL , MAX_LOG_LEVEL }

enum class	QuoteFormat : uint8_t { oe_sgx_v1 = 0 , insecure_virtual = 1 , amd_sev_snp_v1 = 2 }

enum class	FrameFormat : uint8_t { http = 0 }

enum class	ActionFormat : uint8_t { COSE = 0 , JSON = 1 }

enum class	FetchStatus : uint8_t { Retry , Done , Failed }
	Status of the network identity endorsement fetching process. More...

enum class	LedgerSignMode : uint8_t { Dual = 0 , CoseAllowDualJoin = 1 , CoseOnly = 2 }

enum class	QuoteVerificationResult : uint8_t { Verified = 0 , Failed , FailedMeasurementNotFound , FailedHostDataDigestNotFound , FailedInvalidHostData , FailedInvalidQuotedPublicKey , FailedUVMEndorsementsNotFound , FailedInvalidCPUID , FailedInvalidTcbVersion }

enum class	NodeStartupState : uint8_t { uninitialized , initialized , pending , partOfPublicNetwork , partOfNetwork , readingPublicLedger , readingPrivateLedger }

enum	MerkleProofLabel : int64_t { MERKLE_PROOF_LEAF_LABEL = 1 , MERKLE_PROOF_PATH_LABEL = 2 }

enum	MerkleProofPathBranch : int64_t { LEFT = 0 , RIGHT = 1 }

enum class	CodeStatus : uint8_t { ALLOWED_TO_JOIN = 0 }

enum	ConsensusType : uint8_t { CFT = 0 , BFT = 1 }

enum	DerivedSealingKeyAlgorithm : uint8_t { SNP_v1 = 0 }

enum class	NodeStatus : uint8_t { PENDING = 0 , TRUSTED = 1 , RETIRED = 2 }

enum class	Authority : uint8_t { NODE , SERVICE , ACME , UNSECURED }

enum class	RedirectionResolutionKind : uint8_t { NodeByRole , StaticAddress }

enum	ReconfigurationType : uint8_t { ONE_TRANSACTION = 0 , TWO_TRANSACTION = 1 }

enum class	JwtIssuerKeyFilter : uint8_t { All }

enum class	MemberStatus : uint8_t { ACCEPTED = 0 , ACTIVE = 1 }

enum class	MemberRecoveryRole : uint8_t { NonParticipant = 0 , Participant , Owner }

enum class	ProposalState : uint8_t { OPEN , ACCEPTED , WITHDRAWN , REJECTED , FAILED , DROPPED }

enum class	ServiceStatus : uint8_t { OPENING = 1 , OPEN = 2 , WAITING_FOR_RECOVERY_SHARES = 3 , RECOVERING = 4 }

enum class	TxStatus : uint8_t { Unknown , Pending , Committed , Invalid }

enum class	FinalTxStatus : std::underlying_type_t< TxStatus >

enum class	ActorsType : uint8_t { members = 0 , users , nodes , unknown }

enum	SessionStatus : uint8_t { handshake , ready , closing , closed , authfail , error }

enum	ChannelStatus : uint8_t { INACTIVE = 0 , INITIATED , WAITING_FOR_FINAL , ESTABLISHED }

enum	HashOp : uint8_t { 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 : uint8_t { HTTP1 = 0 , HTTP2 }

enum	RecoveryType : std::uint8_t { 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 *claims_digest_type)

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

	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)

	DECLARE_JSON_TYPE (EndpointMetricsEntry)

	DECLARE_JSON_REQUIRED_FIELDS (EndpointMetricsEntry, path, method, calls, errors, failures, retries)

	DECLARE_JSON_TYPE (EndpointMetrics)

	DECLARE_JSON_REQUIRED_FIELDS (EndpointMetrics, metrics)

std::optional< OpenAPISecuritySchema >	get_cert_based_security_schema ()

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

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

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

	DECLARE_JSON_TYPE (AuditInfo)

	DECLARE_JSON_REQUIRED_FIELDS (AuditInfo, format, user_id, action_name)

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)

jsonhandler::JsonAdapterResponse	already_populated_response ()

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)

	DECLARE_JSON_ENUM (LedgerSignMode, {{LedgerSignMode::Dual, "Dual"}, {LedgerSignMode::CoseAllowDualJoin, "CoseAllowDualJoin"}, {LedgerSignMode::CoseOnly, "CoseOnly"}})

LedgerSignMode	get_ledger_sign_mode ()

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

	DECLARE_JSON_ENUM (ccf::NodeStartupState, {{ccf::NodeStartupState::uninitialized, "Uninitialized"}, {ccf::NodeStartupState::initialized, "Initialized"}, {ccf::NodeStartupState::pending, "Pending"}, {ccf::NodeStartupState::partOfPublicNetwork, "PartOfPublicNetwork"}, {ccf::NodeStartupState::partOfNetwork, "PartOfNetwork"}, {ccf::NodeStartupState::readingPublicLedger, "ReadingPublicLedger"}, {ccf::NodeStartupState::readingPrivateLedger, "ReadingPrivateLedger"}})

	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)

std::optional< SerialisedCoseReceipt >	describe_cose_receipt_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 *components)

void	fill_json_schema (nlohmann::json &schema, const ProofReceipt::Components *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 *step)

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

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

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

std::string	schema_name (const ReceiptPtr *receipt)

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

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

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

int	run (int argc, char **argv)

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

	DECLARE_JSON_ENUM (ConsensusType, {{ConsensusType::CFT, "CFT"}, {ConsensusType::BFT, "BFT"}})

	DECLARE_JSON_ENUM (DerivedSealingKeyAlgorithm, {{DerivedSealingKeyAlgorithm::SNP_v1, "SNP_TCB_v1"}})

	DECLARE_JSON_TYPE (SealedRecoveryKey)

	DECLARE_JSON_REQUIRED_FIELDS (SealedRecoveryKey, version, ciphertext, pubkey, tcb_version)

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

	DECLARE_JSON_REQUIRED_FIELDS (Endorsement, authority)

	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, enabled_operator_features, redirections)

	DECLARE_JSON_TYPE (NodeInfoNetwork_v2)

	DECLARE_JSON_REQUIRED_FIELDS (NodeInfoNetwork_v2, node_to_node_interface, rpc_interfaces)

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

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

	DECLARE_JSON_ENUM (ReconfigurationType, {{ReconfigurationType::ONE_TRANSACTION, "OneTransaction"}, {ReconfigurationType::TWO_TRANSACTION, "TwoTransaction"}})

	DECLARE_JSON_TYPE (SignedReq)

	DECLARE_JSON_REQUIRED_FIELDS (SignedReq, sig, req, request_body, md, key_id)

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

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

std::string	schema_name (const JSRuntimeOptions *runtime_options_type)

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

	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_TYPE (JsonWebKeySet)

	DECLARE_JSON_REQUIRED_FIELDS (JsonWebKeySet, keys)

	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_TYPE_WITH_OPTIONAL_FIELDS (NewMember)

	DECLARE_JSON_REQUIRED_FIELDS (NewMember, cert)

	DECLARE_JSON_OPTIONAL_FIELDS (NewMember, encryption_pub_key, member_data, recovery_role)

	DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS (MemberDetails)

	DECLARE_JSON_REQUIRED_FIELDS (MemberDetails, status)

	DECLARE_JSON_OPTIONAL_FIELDS (MemberDetails, member_data, recovery_role)

	DECLARE_JSON_TYPE (StateDigest)

	DECLARE_JSON_REQUIRED_FIELDS (StateDigest, state_digest)

	DECLARE_JSON_TYPE_WITH_BASE_AND_OPTIONAL_FIELDS (MemberAck, StateDigest)

	DECLARE_JSON_REQUIRED_FIELDS (MemberAck)

	DECLARE_JSON_OPTIONAL_FIELDS (MemberAck, signed_req, cose_sign1_req)

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::ECKeyPairPtr &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_WITH_OPTIONAL_FIELDS (NewUser)

	DECLARE_JSON_REQUIRED_FIELDS (NewUser, cert)

	DECLARE_JSON_OPTIONAL_FIELDS (NewUser, user_data)

	DECLARE_JSON_TYPE (UserDetails)

	DECLARE_JSON_REQUIRED_FIELDS (UserDetails, user_data)

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

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

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_REQUIRED_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::BackupFetch)

	DECLARE_JSON_REQUIRED_FIELDS (CCFConfig::Snapshots::BackupFetch)

	DECLARE_JSON_OPTIONAL_FIELDS (CCFConfig::Snapshots::BackupFetch, enabled, max_attempts, retry_interval, target_rpc_interface, max_size)

	DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS (CCFConfig::Snapshots)

	DECLARE_JSON_REQUIRED_FIELDS (CCFConfig::Snapshots)

	DECLARE_JSON_OPTIONAL_FIELDS (CCFConfig::Snapshots, directory, tx_count, min_tx_count, time_interval, read_only_directory, backup_fetch)

	DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS (CCFConfig::FilesCleanup)

	DECLARE_JSON_REQUIRED_FIELDS (CCFConfig::FilesCleanup)

	DECLARE_JSON_OPTIONAL_FIELDS (CCFConfig::FilesCleanup, max_snapshots, max_committed_ledger_chunks, interval)

	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, files_cleanup, node_to_node_message_limit, historical_cache_soft_limit)

	DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS (RecoveryDecisionProtocolConfig)

	DECLARE_JSON_REQUIRED_FIELDS (RecoveryDecisionProtocolConfig, expected_locations)

	DECLARE_JSON_OPTIONAL_FIELDS (RecoveryDecisionProtocolConfig, message_retry_timeout, failover_timeout)

	DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS (SealingRecoveryConfig)

	DECLARE_JSON_REQUIRED_FIELDS (SealingRecoveryConfig, location)

	DECLARE_JSON_OPTIONAL_FIELDS (SealingRecoveryConfig, recovery_decision_protocol)

	DECLARE_JSON_TYPE (StartupConfig::Start)

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

	DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS (StartupConfig::Join)

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

	DECLARE_JSON_OPTIONAL_FIELDS (StartupConfig::Join, host_data_transparent_statement_path)

	DECLARE_JSON_TYPE (StartupConfig::Recover)

	DECLARE_JSON_REQUIRED_FIELDS (StartupConfig::Recover, previous_service_identity)

	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, sealing_recovery)

bool	is_valid_actor (const std::string &actor)

constexpr auto	get_actor_prefix (ActorsType at)

CreateNodeStatus	enclave_create_node (const EnclaveConfig &enclave_config, const ccf::StartupConfig &ccf_config, std::vector< uint8_t > &node_cert, std::vector< uint8_t > &service_cert, StartType start_type, ccf::LoggerLevel log_level, size_t num_worker_thread, const ccf::ds::WorkBeaconPtr &work_beacon, asynchost::Ledger &ledger)

bool	enclave_run ()

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

void	validate_and_adjust_recovery_threshold (host::CCHostConfig &config)

void	setup_rpc_interfaces (host::CCHostConfig &config, asynchost::RPCConnections< asynchost::TCP > &rpc, asynchost::RPCConnections< asynchost::UDP > &rpc_udp)

void	configure_snp_attestation (ccf::StartupConfig &startup_config)

void	populate_config_for_start (const host::CCHostConfig &config, ccf::StartupConfig &startup_config)

void	populate_config_for_join (const host::CCHostConfig &config, ccf::StartupConfig &startup_config)

void	populate_config_for_recover (const host::CCHostConfig &config, ccf::StartupConfig &startup_config)

std::optional< size_t >	create_enclave_node (const host::CCHostConfig &config, messaging::BufferProcessor &buffer_processor, ringbuffer::Circuit &circuit, EnclaveConfig &enclave_config, ccf::StartupConfig &startup_config, std::vector< uint8_t > &node_cert, std::vector< uint8_t > &service_cert, ccf::LoggerLevel log_level, ringbuffer::NotifyingWriterFactory &notifying_factory, asynchost::Ledger &ledger)

void	write_certificates_to_disk (const host::CCHostConfig &config, const std::vector< uint8_t > &node_cert, const std::vector< uint8_t > &service_cert)

void	run_enclave_threads (const host::CCHostConfig &config)

std::optional< size_t >	run_main_loop (host::CCHostConfig &config, messaging::BufferProcessor &buffer_processor, ringbuffer::Circuit &circuit, EnclaveConfig &enclave_config, ccf::LoggerLevel log_level)

void	apply_stdlib_workarounds ()

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)

WireNonce	get_wire_nonce (const GcmHdr &header)

template<typename T >
void	append_value (std::vector< uint8_t > &target, const T &t)

void	append_buffer (std::vector< uint8_t > &target, std::span< const uint8_t > src)

	DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS (LedgerSecret)

	DECLARE_JSON_REQUIRED_FIELDS (LedgerSecret, raw_key)

	DECLARE_JSON_OPTIONAL_FIELDS (LedgerSecret, previous_secret_stored_version)

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)

LedgerSignMode	__attribute__ ((weak)) get_ledger_sign_mode()

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

ccf::kv::Term	resolve_latest_sig_view (ccf::kv::ReadOnlyTx &tx)

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< HostData > &host_data)

QuoteVerificationResult	verify_code_transparent_statement (ccf::kv::ReadOnlyTx &tx, const std::vector< uint8_t > &ts_raw, const HostData &host_data, std::shared_ptr< NetworkIdentitySubsystemInterface > network_identity_subsystem)

void	dispatch_authenticated_message (nlohmann::json &request, const std::string &target_address, const std::string &endpoint, const crypto::Pem &self_signed_node_cert, const crypto::Pem &privkey_pem)

	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 (GetHistoricalCacheInfo::Out)

	DECLARE_JSON_REQUIRED_FIELDS (GetHistoricalCacheInfo::Out, estimated_size)

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

	DECLARE_JSON_REQUIRED_FIELDS (JWTRefreshMetrics, attempts, successes, failures)

	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_WITH_OPTIONAL_FIELDS (GetState::Out)

	DECLARE_JSON_REQUIRED_FIELDS (GetState::Out, node_id, state, last_signed_seqno, startup_seqno, stop_notice)

	DECLARE_JSON_OPTIONAL_FIELDS (GetState::Out, recovery_target_seqno, last_recovered_seqno)

	DECLARE_JSON_TYPE (GetVersion::Out)

	DECLARE_JSON_REQUIRED_FIELDS (GetVersion::Out, ccf_version, quickjs_version, unsafe)

	DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS (JoinNetworkNodeToNode::In)

	DECLARE_JSON_REQUIRED_FIELDS (JoinNetworkNodeToNode::In, node_info_network, quote_info, public_encryption_key, startup_seqno)

	DECLARE_JSON_OPTIONAL_FIELDS (JoinNetworkNodeToNode::In, certificate_signing_request, node_data, sealing_recovery_data, code_transparent_statement, ledger_sign_mode, join_fetch_count)

	DECLARE_JSON_TYPE (NetworkIdentity)

	DECLARE_JSON_REQUIRED_FIELDS (NetworkIdentity, cert, priv_key)

	DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS (JoinNetworkNodeToNode::Out::NetworkInfo)

	DECLARE_JSON_REQUIRED_FIELDS (JoinNetworkNodeToNode::Out::NetworkInfo, public_only, last_recovered_signed_idx, ledger_secrets, identity)

	DECLARE_JSON_OPTIONAL_FIELDS (JoinNetworkNodeToNode::Out::NetworkInfo, service_status, endorsed_certificate, cose_signatures_config)

	DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS (JoinNetworkNodeToNode::Out)

	DECLARE_JSON_REQUIRED_FIELDS (JoinNetworkNodeToNode::Out, node_status)

	DECLARE_JSON_OPTIONAL_FIELDS (JoinNetworkNodeToNode::Out, node_id, network_info)

	DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS (CreateNetworkNodeToNode::In)

	DECLARE_JSON_REQUIRED_FIELDS (CreateNetworkNodeToNode::In, node_id, certificate_signing_request, node_endorsed_certificate, public_key, service_cert, quote_info, public_encryption_key, measurement, node_info_network, create_txid)

	DECLARE_JSON_OPTIONAL_FIELDS (CreateNetworkNodeToNode::In, genesis_info, node_data, service_data, snp_security_policy, snp_uvm_endorsements, sealing_recovery_data)

	DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS (GetCommit::Out)

	DECLARE_JSON_REQUIRED_FIELDS (GetCommit::Out, transaction_id)

	DECLARE_JSON_OPTIONAL_FIELDS (GetCommit::Out, view_history)

	DECLARE_JSON_TYPE (GetTxStatus::Out)

	DECLARE_JSON_REQUIRED_FIELDS (GetTxStatus::Out, transaction_id, status)

	DECLARE_JSON_TYPE (GetNetworkInfo::Out)

	DECLARE_JSON_REQUIRED_FIELDS (GetNetworkInfo::Out, service_status, service_certificate, current_view, primary_id, recovery_count, service_data, current_service_create_txid)

	DECLARE_JSON_TYPE (GetNode::NodeInfo)

	DECLARE_JSON_REQUIRED_FIELDS (GetNode::NodeInfo, node_id, status, primary, rpc_interfaces, node_data, last_written)

	DECLARE_JSON_TYPE (GetNodes::Out)

	DECLARE_JSON_REQUIRED_FIELDS (GetNodes::Out, nodes)

	DECLARE_JSON_TYPE (VerifyReceipt::In)

	DECLARE_JSON_REQUIRED_FIELDS (VerifyReceipt::In, receipt)

	DECLARE_JSON_TYPE (VerifyReceipt::Out)

	DECLARE_JSON_REQUIRED_FIELDS (VerifyReceipt::Out, valid)

	DECLARE_JSON_TYPE (GetCode::Version)

	DECLARE_JSON_REQUIRED_FIELDS (GetCode::Version, digest, status)

	DECLARE_JSON_TYPE (GetCode::Out)

	DECLARE_JSON_REQUIRED_FIELDS (GetCode::Out, versions)

	DECLARE_JSON_TYPE (GetSnpHostDataMap::HostData)

	DECLARE_JSON_REQUIRED_FIELDS (GetSnpHostDataMap::HostData, raw, metadata)

	DECLARE_JSON_TYPE (GetSnpHostDataMap::Out)

	DECLARE_JSON_REQUIRED_FIELDS (GetSnpHostDataMap::Out, host_data)

	DECLARE_JSON_TYPE (GetRecoveryShare::Out)

	DECLARE_JSON_REQUIRED_FIELDS (GetRecoveryShare::Out, encrypted_share)

	DECLARE_JSON_TYPE (SubmitRecoveryShare::In)

	DECLARE_JSON_REQUIRED_FIELDS (SubmitRecoveryShare::In, share)

	DECLARE_JSON_TYPE (SubmitRecoveryShare::Out)

	DECLARE_JSON_REQUIRED_FIELDS (SubmitRecoveryShare::Out, message)

	DECLARE_JSON_TYPE (SessionMetrics::Errors)

	DECLARE_JSON_REQUIRED_FIELDS (SessionMetrics::Errors, parsing, request_payload_too_large, request_header_too_large)

	DECLARE_JSON_TYPE (SessionMetrics::PerInterface)

	DECLARE_JSON_REQUIRED_FIELDS (SessionMetrics::PerInterface, active, peak, soft_cap, hard_cap, errors)

	DECLARE_JSON_TYPE (SessionMetrics)

	DECLARE_JSON_REQUIRED_FIELDS (SessionMetrics, active, peak, interfaces)

size_t	parse_svn (const std::string &svn_str)

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)

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_TYPE_WITH_OPTIONAL_FIELDS (ServiceConfiguration)

	DECLARE_JSON_REQUIRED_FIELDS (ServiceConfiguration, recovery_threshold)

	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_TYPE_WITH_OPTIONAL_FIELDS (SealedSharesInfo)

	DECLARE_JSON_REQUIRED_FIELDS (SealedSharesInfo, wrapped_latest_ledger_secret, encrypted_wrapping_keys)

	DECLARE_JSON_OPTIONAL_FIELDS (SealedSharesInfo, previous_secret_stored_version)

	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_TYPE_WITH_OPTIONAL_FIELDS (EncryptedLedgerSecret)

	DECLARE_JSON_REQUIRED_FIELDS (EncryptedLedgerSecret, version, encrypted_secret)

	DECLARE_JSON_OPTIONAL_FIELDS (EncryptedLedgerSecret, previous_secret_stored_version)

	DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS (RecoverySharesInfo)

	DECLARE_JSON_REQUIRED_FIELDS (RecoverySharesInfo, wrapped_latest_ledger_secret, encrypted_shares)

	DECLARE_JSON_OPTIONAL_FIELDS (RecoverySharesInfo, previous_secret_stored_version)

	DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS (PreviousLedgerSecretInfo)

	DECLARE_JSON_REQUIRED_FIELDS (PreviousLedgerSecretInfo, encrypted_data, version)

	DECLARE_JSON_OPTIONAL_FIELDS (PreviousLedgerSecretInfo, previous_secret_stored_version)

	DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS (EncryptedLedgerSecretInfo)

	DECLARE_JSON_REQUIRED_FIELDS (EncryptedLedgerSecretInfo)

	DECLARE_JSON_OPTIONAL_FIELDS (EncryptedLedgerSecretInfo, previous_ledger_secret, next_version)

	DECLARE_JSON_TYPE_WITH_BASE_AND_OPTIONAL_FIELDS (PrimarySignature, NodeSignature)

	DECLARE_JSON_REQUIRED_FIELDS (PrimarySignature, seqno, view, commit_seqno, commit_view, root)

	DECLARE_JSON_OPTIONAL_FIELDS (PrimarySignature, cert)

	DECLARE_JSON_TYPE (SnapshotHash)

	DECLARE_JSON_REQUIRED_FIELDS (SnapshotHash, hash, version)

	DECLARE_JSON_TYPE (SnapshotStatus)

	DECLARE_JSON_REQUIRED_FIELDS (SnapshotStatus, version, timestamp)

Variables
constexpr View	VIEW_UNKNOWN = 0

constexpr SeqNo	SEQNO_UNKNOWN = 0

constexpr int	MAX_HISTORY_LEN = 0

Detailed Description

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

Typedef Documentation

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

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

◆ CodeUpdatePolicy

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

◆ CommandHandlerWithJson

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

◆ CommitCallback

using ccf::CommitCallback = typedef std::function<void(ccf::TxID, ccf::FinalTxStatus)>

◆ Configuration

using ccf::Configuration = typedef ServiceValue<ServiceConfiguration>

◆ ConsensusConfig

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

◆ Constitution

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

◆ CoseEndorsementsChain

using ccf::CoseEndorsementsChain = typedef std::vector<RawCoseEndorsement>

An ordered chain of raw COSE endorsements.

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

◆ ECPublicKey

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

◆ EncryptedLedgerSecrets

using ccf::EncryptedLedgerSecrets = typedef std::vector<EncryptedLedgerSecret>

◆ EncryptedLedgerSecretsInfo

using ccf::EncryptedLedgerSecretsInfo = typedef ServiceValue<EncryptedLedgerSecretInfo>

◆ EncryptedSealedSharesMap

using ccf::EncryptedSealedSharesMap = typedef std::map<NodeId, EncryptedShare>

◆ 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

◆ LocalSealingNodeIdMap

using ccf::LocalSealingNodeIdMap = typedef ServiceMap<sealing_recovery::Name, NodeId>

◆ 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

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

◆ RawCoseEndorsement

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

A single raw COSE endorsement, stored as an opaque byte vector.

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

◆ RecoveryShares

using ccf::RecoveryShares = typedef ServiceValue<RecoverySharesInfo>

◆ SealedRecoveryKeys

using ccf::SealedRecoveryKeys = typedef ServiceMap<NodeId, ccf::SealedRecoveryKey>

◆ SealedShares

using ccf::SealedShares = typedef ServiceValue<SealedSharesInfo>

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

◆ SerialisedCoseReceipt

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

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

◆ ServiceUnit

using ccf::ServiceUnit = typedef ccf::kv::UnitValue<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>

◆ SnapshotCreate

using ccf::SnapshotCreate = typedef ServiceUnit

◆ SnapshotEvidence

using ccf::SnapshotEvidence = typedef ServiceValue<SnapshotHash>

◆ SnapshotStatusValue

using ccf::SnapshotStatusValue = typedef ServiceValue<SnapshotStatus>

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

◆ TrustedKeys

using ccf::TrustedKeys = typedef std::map<ccf::SeqNo, ccf::crypto::ECPublicKeyPtr>

Map from sequence number to EC public key, representing the trusted network identity keys over the history of the service.

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

strong

Enumerator
COSE
JSON

◆ ActorsType

enum class ccf::ActorsType : uint8_t

strong

Enumerator
members
users
nodes
unknown

◆ ApiResult

enum class ccf::ApiResult : uint8_t

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 requested 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 : uint8_t

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

Enumerator
INACTIVE
INITIATED
WAITING_FOR_FINAL
ESTABLISHED

◆ CodeStatus

enum class ccf::CodeStatus : uint8_t

strong

Enumerator
ALLOWED_TO_JOIN

◆ ConsensusType

enum ccf::ConsensusType : uint8_t

Enumerator
CFT
BFT

◆ DerivedSealingKeyAlgorithm

enum ccf::DerivedSealingKeyAlgorithm : uint8_t

Enumerator
SNP_v1

◆ FetchStatus

enum class ccf::FetchStatus : uint8_t

strong

Status of the network identity endorsement fetching process.

Enumerator
Retry	Fetching should be retried.
Done	Fetching completed successfully.
Failed	Fetching failed.

◆ FinalTxStatus

enum class ccf::FinalTxStatus : std::underlying_type_t< TxStatus >

strong

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

Enumerator
APPEND
VERIFY
ROLLBACK
COMPACT

◆ HttpVersion

enum class ccf::HttpVersion : uint8_t

strong

Enumerator
HTTP1
HTTP2

◆ InvalidArgsReason

enum class ccf::InvalidArgsReason : uint8_t

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

strong

Enumerator
All

◆ LedgerSignMode

enum class ccf::LedgerSignMode : uint8_t

strong

Enumerator
Dual
CoseAllowDualJoin
CoseOnly

◆ LoggerLevel

enum class ccf::LoggerLevel : uint8_t

strong

Enumerator
TRACE
DEBUG
INFO
FAIL
FATAL
MAX_LOG_LEVEL

◆ MemberRecoveryRole

enum class ccf::MemberRecoveryRole : uint8_t

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

strong

Enumerator
ACCEPTED
ACTIVE

◆ MerkleProofLabel

enum ccf::MerkleProofLabel : int64_t

Enumerator
MERKLE_PROOF_LEAF_LABEL
MERKLE_PROOF_PATH_LABEL

◆ MerkleProofPathBranch

enum ccf::MerkleProofPathBranch : int64_t

Enumerator
LEFT
RIGHT

◆ NodeMsgType

enum ccf::NodeMsgType : Node2NodeMsg

Enumerator
channel_msg
consensus_msg
forwarded_msg

◆ NodeStartupState

enum class ccf::NodeStartupState : uint8_t

strong

Enumerator
uninitialized
initialized
pending
partOfPublicNetwork
partOfNetwork
readingPublicLedger
readingPrivateLedger

◆ NodeStatus

enum class ccf::NodeStatus : uint8_t

strong

Enumerator
PENDING
TRUSTED
RETIRED

◆ ProposalState

enum class ccf::ProposalState : uint8_t

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

strong

Enumerator
oe_sgx_v1
insecure_virtual
amd_sev_snp_v1

◆ QuoteVerificationResult

enum class ccf::QuoteVerificationResult : uint8_t

strong

Enumerator
Verified
Failed
FailedMeasurementNotFound
FailedHostDataDigestNotFound
FailedInvalidHostData
FailedInvalidQuotedPublicKey
FailedUVMEndorsementsNotFound
FailedInvalidCPUID
FailedInvalidTcbVersion

◆ ReconfigurationType

enum ccf::ReconfigurationType : uint8_t

Enumerator
ONE_TRANSACTION
TWO_TRANSACTION

◆ RecoveryType

enum ccf::RecoveryType : std::uint8_t

Enumerator
NONE
RECOVERY_SHARES
LOCAL_UNSEALING

◆ RedirectionResolutionKind

enum class ccf::RedirectionResolutionKind : uint8_t

strong

Enumerator
NodeByRole
StaticAddress

◆ ServiceStatus

enum class ccf::ServiceStatus : uint8_t

strong

Enumerator
OPENING
OPEN
WAITING_FOR_RECOVERY_SHARES
RECOVERING

◆ SessionStatus

enum ccf::SessionStatus : uint8_t

Enumerator
handshake
ready
closing
closed
authfail
error

◆ TxStatus

enum class ccf::TxStatus : uint8_t

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
	)

◆ already_populated_response()

jsonhandler::JsonAdapterResponse ccf::already_populated_response ( )

◆ api_result_to_str()

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

constexpr

◆ append_buffer()

void ccf::append_buffer	(	std::vector< uint8_t > &	target,
		std::span< const uint8_t >	src
	)

inline

◆ append_value()

template<typename T >

void ccf::append_value	(	std::vector< uint8_t > &	target,
		const T &	t
	)

inline

◆ apply_stdlib_workarounds()

void ccf::apply_stdlib_workarounds ( )

◆ 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::ECKeyPairPtr & 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

◆ configure_snp_attestation()

void ccf::configure_snp_attestation ( ccf::StartupConfig & startup_config )

◆ create_enclave_node()

std::optional< size_t > ccf::create_enclave_node	(	const host::CCHostConfig &	config,
		messaging::BufferProcessor &	buffer_processor,
		ringbuffer::Circuit &	circuit,
		EnclaveConfig &	enclave_config,
		ccf::StartupConfig &	startup_config,
		std::vector< uint8_t > &	node_cert,
		std::vector< uint8_t > &	service_cert,
		ccf::LoggerLevel	log_level,
		ringbuffer::NotifyingWriterFactory &	notifying_factory,
		asynchost::Ledger &	ledger
	)

◆ DECLARE_JSON_ENUM() [1/19]

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

◆ DECLARE_JSON_ENUM() [2/19]

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

◆ DECLARE_JSON_ENUM() [3/19]

ccf::DECLARE_JSON_ENUM	(	ccf::NodeStartupState	,
		{{ccf::NodeStartupState::uninitialized, "Uninitialized"}, {ccf::NodeStartupState::initialized, "Initialized"}, {ccf::NodeStartupState::pending, "Pending"}, {ccf::NodeStartupState::partOfPublicNetwork, "PartOfPublicNetwork"}, {ccf::NodeStartupState::partOfNetwork, "PartOfNetwork"}, {ccf::NodeStartupState::readingPublicLedger, "ReadingPublicLedger"}, {ccf::NodeStartupState::readingPrivateLedger, "ReadingPrivateLedger"}}
	)

◆ DECLARE_JSON_ENUM() [4/19]

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

◆ DECLARE_JSON_ENUM() [5/19]

ccf::DECLARE_JSON_ENUM	(	ConsensusType	,
		{{ConsensusType::CFT, "CFT"}, {ConsensusType::BFT, "BFT"}}
	)

◆ DECLARE_JSON_ENUM() [6/19]

ccf::DECLARE_JSON_ENUM	(	DerivedSealingKeyAlgorithm	,
		{{DerivedSealingKeyAlgorithm::SNP_v1, "SNP_TCB_v1"}}
	)

◆ DECLARE_JSON_ENUM() [7/19]

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

◆ DECLARE_JSON_ENUM() [8/19]

ccf::DECLARE_JSON_ENUM	(	LedgerSignMode	,
		{{LedgerSignMode::Dual, "Dual"}, {LedgerSignMode::CoseAllowDualJoin, "CoseAllowDualJoin"}, {LedgerSignMode::CoseOnly, "CoseOnly"}}
	)

◆ DECLARE_JSON_ENUM() [9/19]

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

◆ DECLARE_JSON_ENUM() [10/19]

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

◆ DECLARE_JSON_ENUM() [11/19]

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

◆ DECLARE_JSON_ENUM() [12/19]

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

◆ DECLARE_JSON_ENUM() [13/19]

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

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

ccf::DECLARE_JSON_ENUM	(	ReconfigurationType	,
		{{ReconfigurationType::ONE_TRANSACTION, "OneTransaction"}, {ReconfigurationType::TWO_TRANSACTION, "TwoTransaction"}}
	)

◆ DECLARE_JSON_ENUM() [16/19]

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

◆ DECLARE_JSON_ENUM() [17/19]

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

◆ DECLARE_JSON_ENUM() [18/19]

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

◆ DECLARE_JSON_ENUM() [19/19]

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

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

◆ DECLARE_JSON_OPTIONAL_FIELDS() [2/44]

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

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

◆ DECLARE_JSON_OPTIONAL_FIELDS() [4/44]

ccf::DECLARE_JSON_OPTIONAL_FIELDS	(	CCFConfig::FilesCleanup	,
		max_snapshots	,
		max_committed_ledger_chunks	,
		interval
	)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [5/44]

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

◆ DECLARE_JSON_OPTIONAL_FIELDS() [6/44]

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

◆ DECLARE_JSON_OPTIONAL_FIELDS() [7/44]

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

◆ DECLARE_JSON_OPTIONAL_FIELDS() [8/44]

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

◆ DECLARE_JSON_OPTIONAL_FIELDS() [9/44]

ccf::DECLARE_JSON_OPTIONAL_FIELDS	(	CCFConfig::Snapshots	,
		directory	,
		tx_count	,
		min_tx_count	,
		time_interval	,
		read_only_directory	,
		backup_fetch
	)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [10/44]

ccf::DECLARE_JSON_OPTIONAL_FIELDS	(	CCFConfig::Snapshots::BackupFetch	,
		enabled	,
		max_attempts	,
		retry_interval	,
		target_rpc_interface	,
		max_size
	)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [11/44]

ccf::DECLARE_JSON_OPTIONAL_FIELDS	(	CoseEndorsement	,
		previous_version	,
		endorsement_epoch_end
	)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [12/44]

ccf::DECLARE_JSON_OPTIONAL_FIELDS	(	CreateNetworkNodeToNode::In	,
		genesis_info	,
		node_data	,
		service_data	,
		snp_security_policy	,
		snp_uvm_endorsements	,
		sealing_recovery_data
	)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [13/44]

ccf::DECLARE_JSON_OPTIONAL_FIELDS	(	EncryptedLedgerSecret	,
		previous_secret_stored_version
	)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [14/44]

ccf::DECLARE_JSON_OPTIONAL_FIELDS	(	EncryptedLedgerSecretInfo	,
		previous_ledger_secret	,
		next_version
	)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [15/44]

ccf::DECLARE_JSON_OPTIONAL_FIELDS	(	GetCommit::Out	,
		view_history
	)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [16/44]

ccf::DECLARE_JSON_OPTIONAL_FIELDS	(	GetState::Out	,
		recovery_target_seqno	,
		last_recovered_seqno
	)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [17/44]

ccf::DECLARE_JSON_OPTIONAL_FIELDS	(	JoinNetworkNodeToNode::In	,
		certificate_signing_request	,
		node_data	,
		sealing_recovery_data	,
		code_transparent_statement	,
		ledger_sign_mode	,
		join_fetch_count
	)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [18/44]

ccf::DECLARE_JSON_OPTIONAL_FIELDS	(	JoinNetworkNodeToNode::Out	,
		node_id	,
		network_info
	)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [19/44]

ccf::DECLARE_JSON_OPTIONAL_FIELDS	(	JoinNetworkNodeToNode::Out::NetworkInfo	,
		service_status	,
		endorsed_certificate	,
		cose_signatures_config
	)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [20/44]

ccf::DECLARE_JSON_OPTIONAL_FIELDS	(	JwtIssuerMetadata	,
		ca_cert_bundle_name	,
		auto_refresh
	)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [21/44]

ccf::DECLARE_JSON_OPTIONAL_FIELDS	(	LedgerSecret	,
		previous_secret_stored_version
	)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [22/44]

ccf::DECLARE_JSON_OPTIONAL_FIELDS	(	MemberAck	,
		signed_req	,
		cose_sign1_req
	)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [23/44]

ccf::DECLARE_JSON_OPTIONAL_FIELDS	(	MemberDetails	,
		member_data	,
		recovery_role
	)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [24/44]

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

◆ DECLARE_JSON_OPTIONAL_FIELDS() [25/44]

ccf::DECLARE_JSON_OPTIONAL_FIELDS	(	NewUser	,
		user_data
	)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [26/44]

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

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	,
		enabled_operator_features	,
		redirections
	)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [28/44]

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

◆ DECLARE_JSON_OPTIONAL_FIELDS() [29/44]

ccf::DECLARE_JSON_OPTIONAL_FIELDS	(	ODataError	,
		details
	)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [30/44]

ccf::DECLARE_JSON_OPTIONAL_FIELDS	(	ODataJSExceptionDetails	,
		trace
	)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [31/44]

ccf::DECLARE_JSON_OPTIONAL_FIELDS	(	OpenIDJWKMetadata	,
		constraint
	)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [32/44]

ccf::DECLARE_JSON_OPTIONAL_FIELDS	(	OpenIDJWKMetadataLegacy	,
		constraint
	)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [33/44]

ccf::DECLARE_JSON_OPTIONAL_FIELDS	(	PreviousLedgerSecretInfo	,
		previous_secret_stored_version
	)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [34/44]

ccf::DECLARE_JSON_OPTIONAL_FIELDS	(	PrimarySignature	,
		cert
	)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [35/44]

ccf::DECLARE_JSON_OPTIONAL_FIELDS	(	Quote	,
		measurement	,
		uvm_endorsements
	)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [36/44]

ccf::DECLARE_JSON_OPTIONAL_FIELDS	(	QuoteInfo	,
		uvm_endorsements	,
		endorsed_tcb
	)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [37/44]

ccf::DECLARE_JSON_OPTIONAL_FIELDS	(	RecoveryDecisionProtocolConfig	,
		message_retry_timeout	,
		failover_timeout
	)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [38/44]

ccf::DECLARE_JSON_OPTIONAL_FIELDS	(	RecoverySharesInfo	,
		previous_secret_stored_version
	)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [39/44]

ccf::DECLARE_JSON_OPTIONAL_FIELDS	(	RedirectionResolverConfig	,
		target
	)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [40/44]

ccf::DECLARE_JSON_OPTIONAL_FIELDS	(	SealedSharesInfo	,
		previous_secret_stored_version
	)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [41/44]

ccf::DECLARE_JSON_OPTIONAL_FIELDS	(	SealingRecoveryConfig	,
		recovery_decision_protocol
	)

◆ DECLARE_JSON_OPTIONAL_FIELDS() [42/44]

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

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

◆ DECLARE_JSON_OPTIONAL_FIELDS() [44/44]

ccf::DECLARE_JSON_OPTIONAL_FIELDS	(	StartupConfig::Join	,
		host_data_transparent_statement_path
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [1/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( Attestation )

◆ DECLARE_JSON_REQUIRED_FIELDS() [2/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	AuditInfo	,
		format	,
		user_id	,
		action_name
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [3/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	CCFConfig	,
		network
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [4/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( CCFConfig::Attestation )

◆ DECLARE_JSON_REQUIRED_FIELDS() [5/95]

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

◆ DECLARE_JSON_REQUIRED_FIELDS() [6/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( CCFConfig::FilesCleanup )

◆ DECLARE_JSON_REQUIRED_FIELDS() [7/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( CCFConfig::JWT )

◆ DECLARE_JSON_REQUIRED_FIELDS() [8/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( CCFConfig::Ledger )

◆ DECLARE_JSON_REQUIRED_FIELDS() [9/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( CCFConfig::LedgerSignatures )

◆ DECLARE_JSON_REQUIRED_FIELDS() [10/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( CCFConfig::NodeCertificateInfo )

◆ DECLARE_JSON_REQUIRED_FIELDS() [11/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( CCFConfig::Snapshots )

◆ DECLARE_JSON_REQUIRED_FIELDS() [12/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( CCFConfig::Snapshots::BackupFetch )

◆ DECLARE_JSON_REQUIRED_FIELDS() [13/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	ConsensusConfigDetails	,
		details
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [14/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	ConsensusNodeConfig	,
		address
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [15/95]

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

◆ DECLARE_JSON_REQUIRED_FIELDS() [16/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	COSESignaturesConfig	,
		issuer	,
		subject
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [17/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	CreateNetworkNodeToNode::In	,
		node_id	,
		certificate_signing_request	,
		node_endorsed_certificate	,
		public_key	,
		service_cert	,
		quote_info	,
		public_encryption_key	,
		measurement	,
		node_info_network	,
		create_txid
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [18/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	EncryptedLedgerSecret	,
		version	,
		encrypted_secret
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [19/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( EncryptedLedgerSecretInfo )

◆ DECLARE_JSON_REQUIRED_FIELDS() [20/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	Endorsement	,
		authority
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [21/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	EndpointMetrics	,
		metrics
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [22/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	EndpointMetricsEntry	,
		path	,
		method	,
		calls	,
		errors	,
		failures	,
		retries
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [23/95]

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

◆ DECLARE_JSON_REQUIRED_FIELDS() [24/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	GetCode::Out	,
		versions
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [25/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	GetCode::Version	,
		digest	,
		status
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [26/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	GetCommit::Out	,
		transaction_id
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [27/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	GetHistoricalCacheInfo::Out	,
		estimated_size
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [28/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	GetNetworkInfo::Out	,
		service_status	,
		service_certificate	,
		current_view	,
		primary_id	,
		recovery_count	,
		service_data	,
		current_service_create_txid
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [29/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	GetNode::NodeInfo	,
		node_id	,
		status	,
		primary	,
		rpc_interfaces	,
		node_data	,
		last_written
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [30/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	GetNodes::Out	,
		nodes
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [31/95]

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

◆ DECLARE_JSON_REQUIRED_FIELDS() [32/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	GetRecoveryShare::Out	,
		encrypted_share
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [33/95]

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

◆ DECLARE_JSON_REQUIRED_FIELDS() [34/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	GetSnpHostDataMap::HostData	,
		raw	,
		metadata
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [35/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	GetSnpHostDataMap::Out	,
		host_data
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [36/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	GetState::Out	,
		node_id	,
		state	,
		last_signed_seqno	,
		startup_seqno	,
		stop_notice
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [37/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	GetTxStatus::Out	,
		transaction_id	,
		status
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [38/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	GetVersion::Out	,
		ccf_version	,
		quickjs_version	,
		unsafe
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [39/95]

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

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	JoinNetworkNodeToNode::In	,
		node_info_network	,
		quote_info	,
		public_encryption_key	,
		startup_seqno
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [41/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	JoinNetworkNodeToNode::Out	,
		node_status
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [42/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	JoinNetworkNodeToNode::Out::NetworkInfo	,
		public_only	,
		last_recovered_signed_idx	,
		ledger_secrets	,
		identity
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [43/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	JsonWebKeySet	,
		keys
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [44/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( JwtIssuerMetadata )

◆ DECLARE_JSON_REQUIRED_FIELDS() [45/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	JWTRefreshMetrics	,
		attempts	,
		successes	,
		failures
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [46/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	LedgerSecret	,
		raw_key
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [47/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS ( MemberAck )

◆ DECLARE_JSON_REQUIRED_FIELDS() [48/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	MemberDetails	,
		status
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [49/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	NetworkIdentity	,
		cert	,
		priv_key
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [50/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	NewMember	,
		cert
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [51/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	NewUser	,
		cert
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [52/95]

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

◆ DECLARE_JSON_REQUIRED_FIELDS() [53/95]

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

◆ DECLARE_JSON_REQUIRED_FIELDS() [54/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	NodeInfoNetwork_v2	,
		node_to_node_interface	,
		rpc_interfaces
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [55/95]

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

◆ DECLARE_JSON_REQUIRED_FIELDS() [56/95]

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

◆ DECLARE_JSON_REQUIRED_FIELDS() [57/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	NodeMetrics	,
		sessions
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [58/95]

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

◆ DECLARE_JSON_REQUIRED_FIELDS() [59/95]

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

◆ DECLARE_JSON_REQUIRED_FIELDS() [60/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	ODataError	,
		code	,
		message
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [61/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	ODataErrorResponse	,
		error
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [62/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	ODataJSExceptionDetails	,
		code	,
		message
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [63/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	OpenIDJWKMetadata	,
		issuer	,
		public_key
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [64/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	OpenIDJWKMetadataLegacy	,
		issuer	,
		cert
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [65/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	PreviousLedgerSecretInfo	,
		encrypted_data	,
		version
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [66/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	PrimarySignature	,
		seqno	,
		view	,
		commit_seqno	,
		commit_view	,
		root
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [67/95]

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

◆ DECLARE_JSON_REQUIRED_FIELDS() [68/95]

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

◆ DECLARE_JSON_REQUIRED_FIELDS() [69/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	RecoveryDecisionProtocolConfig	,
		expected_locations
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [70/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	RecoverySharesInfo	,
		wrapped_latest_ledger_secret	,
		encrypted_shares
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [71/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	RedirectionResolverConfig	,
		kind
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [72/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	SealedRecoveryKey	,
		version	,
		ciphertext	,
		pubkey	,
		tcb_version
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [73/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	SealedSharesInfo	,
		wrapped_latest_ledger_secret	,
		encrypted_wrapping_keys
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [74/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	SealingRecoveryConfig	,
		location
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [75/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	SelfSignedNodeCertificateInfo	,
		self_signed_certificate
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [76/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	ServiceConfiguration	,
		recovery_threshold
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [77/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	ServiceInfo	,
		cert	,
		status
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [78/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	SessionMetrics	,
		active	,
		peak	,
		interfaces
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [79/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	SessionMetrics::Errors	,
		parsing	,
		request_payload_too_large	,
		request_header_too_large
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [80/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	SessionMetrics::PerInterface	,
		active	,
		peak	,
		soft_cap	,
		hard_cap	,
		errors
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [81/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	SetJwtPublicSigningKeys	,
		issuer	,
		jwks
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [82/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	SignedReq	,
		sig	,
		req	,
		request_body	,
		md	,
		key_id
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [83/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	SnapshotHash	,
		hash	,
		version
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [84/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	SnapshotStatus	,
		version	,
		timestamp
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [85/95]

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	,
		sealing_recovery
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [86/95]

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

◆ DECLARE_JSON_REQUIRED_FIELDS() [87/95]

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

◆ DECLARE_JSON_REQUIRED_FIELDS() [88/95]

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

◆ DECLARE_JSON_REQUIRED_FIELDS() [89/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	StateDigest	,
		state_digest
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [90/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	SubmitRecoveryShare::In	,
		share
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [91/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	SubmitRecoveryShare::Out	,
		message
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [92/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	UserDetails	,
		user_data
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [93/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	UVMEndorsementsData	,
		svn
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [94/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	VerifyReceipt::In	,
		receipt
	)

◆ DECLARE_JSON_REQUIRED_FIELDS() [95/95]

ccf::DECLARE_JSON_REQUIRED_FIELDS	(	VerifyReceipt::Out	,
		valid
	)

◆ DECLARE_JSON_TYPE() [1/49]

ccf::DECLARE_JSON_TYPE ( AuditInfo )

◆ DECLARE_JSON_TYPE() [2/49]

ccf::DECLARE_JSON_TYPE ( ConsensusConfigDetails )

◆ DECLARE_JSON_TYPE() [3/49]

ccf::DECLARE_JSON_TYPE ( ConsensusNodeConfig )

◆ DECLARE_JSON_TYPE() [4/49]

ccf::DECLARE_JSON_TYPE ( COSESignaturesConfig )

◆ DECLARE_JSON_TYPE() [5/49]

ccf::DECLARE_JSON_TYPE ( Endorsement )

◆ DECLARE_JSON_TYPE() [6/49]

ccf::DECLARE_JSON_TYPE ( EndpointMetrics )

◆ DECLARE_JSON_TYPE() [7/49]

ccf::DECLARE_JSON_TYPE ( EndpointMetricsEntry )

◆ DECLARE_JSON_TYPE() [8/49]

ccf::DECLARE_JSON_TYPE ( GetAttestations::Out )

◆ DECLARE_JSON_TYPE() [9/49]

ccf::DECLARE_JSON_TYPE ( GetCode::Out )

◆ DECLARE_JSON_TYPE() [10/49]

ccf::DECLARE_JSON_TYPE ( GetCode::Version )

◆ DECLARE_JSON_TYPE() [11/49]

ccf::DECLARE_JSON_TYPE ( GetHistoricalCacheInfo::Out )

◆ DECLARE_JSON_TYPE() [12/49]

ccf::DECLARE_JSON_TYPE ( GetNetworkInfo::Out )

◆ DECLARE_JSON_TYPE() [13/49]

ccf::DECLARE_JSON_TYPE ( GetNode::NodeInfo )

◆ DECLARE_JSON_TYPE() [14/49]

ccf::DECLARE_JSON_TYPE ( GetNodes::Out )

◆ DECLARE_JSON_TYPE() [15/49]

ccf::DECLARE_JSON_TYPE ( GetQuotes::Out )

◆ DECLARE_JSON_TYPE() [16/49]

ccf::DECLARE_JSON_TYPE ( GetRecoveryShare::Out )

◆ DECLARE_JSON_TYPE() [17/49]

ccf::DECLARE_JSON_TYPE ( GetServicePreviousIdentity::Out )

◆ DECLARE_JSON_TYPE() [18/49]

ccf::DECLARE_JSON_TYPE ( GetSnpHostDataMap::HostData )

◆ DECLARE_JSON_TYPE() [19/49]

ccf::DECLARE_JSON_TYPE ( GetSnpHostDataMap::Out )

◆ DECLARE_JSON_TYPE() [20/49]

ccf::DECLARE_JSON_TYPE ( GetTxStatus::Out )

◆ DECLARE_JSON_TYPE() [21/49]

ccf::DECLARE_JSON_TYPE ( GetVersion::Out )

◆ DECLARE_JSON_TYPE() [22/49]

ccf::DECLARE_JSON_TYPE ( JavaScriptMetrics )

◆ DECLARE_JSON_TYPE() [23/49]

ccf::DECLARE_JSON_TYPE ( JsonWebKeySet )

◆ DECLARE_JSON_TYPE() [24/49]

ccf::DECLARE_JSON_TYPE ( JWTRefreshMetrics )

◆ DECLARE_JSON_TYPE() [25/49]

ccf::DECLARE_JSON_TYPE ( NetworkIdentity )

◆ DECLARE_JSON_TYPE() [26/49]

ccf::DECLARE_JSON_TYPE ( NodeInfoNetwork_v1 )

◆ DECLARE_JSON_TYPE() [27/49]

ccf::DECLARE_JSON_TYPE ( NodeInfoNetwork_v2 )

◆ DECLARE_JSON_TYPE() [28/49]

ccf::DECLARE_JSON_TYPE ( NodeMetrics )

◆ DECLARE_JSON_TYPE() [29/49]

ccf::DECLARE_JSON_TYPE ( NodeSignature )

◆ DECLARE_JSON_TYPE() [30/49]

ccf::DECLARE_JSON_TYPE ( ODataAuthErrorDetails )

◆ DECLARE_JSON_TYPE() [31/49]

ccf::DECLARE_JSON_TYPE ( ODataErrorResponse )

◆ DECLARE_JSON_TYPE() [32/49]

ccf::DECLARE_JSON_TYPE ( SealedRecoveryKey )

◆ DECLARE_JSON_TYPE() [33/49]

ccf::DECLARE_JSON_TYPE ( SelfSignedNodeCertificateInfo )

◆ DECLARE_JSON_TYPE() [34/49]

ccf::DECLARE_JSON_TYPE ( SessionMetrics )

◆ DECLARE_JSON_TYPE() [35/49]

ccf::DECLARE_JSON_TYPE ( SessionMetrics::Errors )

◆ DECLARE_JSON_TYPE() [36/49]

ccf::DECLARE_JSON_TYPE ( SessionMetrics::PerInterface )

◆ DECLARE_JSON_TYPE() [37/49]

ccf::DECLARE_JSON_TYPE ( SetJwtPublicSigningKeys )

◆ DECLARE_JSON_TYPE() [38/49]

ccf::DECLARE_JSON_TYPE ( SignedReq )

◆ DECLARE_JSON_TYPE() [39/49]

ccf::DECLARE_JSON_TYPE ( SnapshotHash )

◆ DECLARE_JSON_TYPE() [40/49]

ccf::DECLARE_JSON_TYPE ( SnapshotStatus )

◆ DECLARE_JSON_TYPE() [41/49]

ccf::DECLARE_JSON_TYPE ( StartupConfig::Recover )

◆ DECLARE_JSON_TYPE() [42/49]

ccf::DECLARE_JSON_TYPE ( StartupConfig::Start )

◆ DECLARE_JSON_TYPE() [43/49]

ccf::DECLARE_JSON_TYPE ( StateDigest )

◆ DECLARE_JSON_TYPE() [44/49]

ccf::DECLARE_JSON_TYPE ( SubmitRecoveryShare::In )

◆ DECLARE_JSON_TYPE() [45/49]

ccf::DECLARE_JSON_TYPE ( SubmitRecoveryShare::Out )

◆ DECLARE_JSON_TYPE() [46/49]

ccf::DECLARE_JSON_TYPE ( UserDetails )

◆ DECLARE_JSON_TYPE() [47/49]

ccf::DECLARE_JSON_TYPE ( UVMEndorsementsData )

◆ DECLARE_JSON_TYPE() [48/49]

ccf::DECLARE_JSON_TYPE ( VerifyReceipt::In )

◆ DECLARE_JSON_TYPE() [49/49]

ccf::DECLARE_JSON_TYPE ( VerifyReceipt::Out )

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

ccf::DECLARE_JSON_TYPE_WITH_BASE_AND_OPTIONAL_FIELDS	(	MemberAck	,
		StateDigest
	)

◆ DECLARE_JSON_TYPE_WITH_BASE_AND_OPTIONAL_FIELDS() [2/3]

ccf::DECLARE_JSON_TYPE_WITH_BASE_AND_OPTIONAL_FIELDS	(	NodeInfo	,
		NodeInfoNetwork
	)

◆ DECLARE_JSON_TYPE_WITH_BASE_AND_OPTIONAL_FIELDS() [3/3]

ccf::DECLARE_JSON_TYPE_WITH_BASE_AND_OPTIONAL_FIELDS	(	PrimarySignature	,
		NodeSignature
	)

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [1/41]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( CCFConfig )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [2/41]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( CCFConfig::Attestation )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [3/41]

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

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [4/41]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( CCFConfig::FilesCleanup )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [5/41]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( CCFConfig::JWT )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [6/41]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( CCFConfig::Ledger )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [7/41]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( CCFConfig::LedgerSignatures )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [8/41]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( CCFConfig::NodeCertificateInfo )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [9/41]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( CCFConfig::Snapshots )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [10/41]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( CCFConfig::Snapshots::BackupFetch )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [11/41]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( CoseEndorsement )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [12/41]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( CreateNetworkNodeToNode::In )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [13/41]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( EncryptedLedgerSecret )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [14/41]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( EncryptedLedgerSecretInfo )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [15/41]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( GetCommit::Out )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [16/41]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( GetState::Out )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [17/41]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( JoinNetworkNodeToNode::In )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [18/41]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( JoinNetworkNodeToNode::Out )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [19/41]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( JoinNetworkNodeToNode::Out::NetworkInfo )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [20/41]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( JwtIssuerMetadata )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [21/41]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( LedgerSecret )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [22/41]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( MemberDetails )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [23/41]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( NewMember )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [24/41]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( NewUser )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [25/41]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( NodeInfoNetwork_v2::NetInterface )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [26/41]

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

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [27/41]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( ODataError )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [28/41]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( ODataJSExceptionDetails )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [29/41]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( OpenIDJWKMetadata )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [30/41]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( OpenIDJWKMetadataLegacy )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [31/41]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( PreviousLedgerSecretInfo )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [32/41]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( Quote )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [33/41]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( QuoteInfo )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [34/41]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( RecoveryDecisionProtocolConfig )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [35/41]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( RecoverySharesInfo )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [36/41]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( RedirectionResolverConfig )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [37/41]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( SealedSharesInfo )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [38/41]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( SealingRecoveryConfig )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [39/41]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( ServiceConfiguration )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [40/41]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( ServiceInfo )

◆ DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS() [41/41]

ccf::DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS ( StartupConfig::Join )

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

std::optional< SerialisedCoseReceipt > ccf::describe_cose_receipt_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 )

◆ dispatch_authenticated_message()

void ccf::dispatch_authenticated_message	(	nlohmann::json &	request,
		const std::string &	target_address,
		const std::string &	endpoint,
		const crypto::Pem &	self_signed_node_cert,
		const crypto::Pem &	privkey_pem
	)

◆ enclave_create_node()

CreateNodeStatus ccf::enclave_create_node	(	const EnclaveConfig &	enclave_config,
		const ccf::StartupConfig &	ccf_config,
		std::vector< uint8_t > &	node_cert,
		std::vector< uint8_t > &	service_cert,
		StartType	start_type,
		ccf::LoggerLevel	log_level,
		size_t	num_worker_thread,
		const ccf::ds::WorkBeaconPtr &	work_beacon,
		asynchost::Ledger &	ledger
	)

◆ enclave_run()

bool ccf::enclave_run ( )

◆ fill_json_schema() [1/8]

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

inline

◆ fill_json_schema() [2/8]

template<typename FmtExtender >

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

inline

◆ fill_json_schema() [3/8]

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

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

inline

◆ fill_json_schema() [8/8]

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

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

std::optional< OpenAPISecuritySchema > ccf::get_cert_based_security_schema ( )

inline

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

LedgerSignMode ccf::get_ledger_sign_mode ( )

Can be optionally implemented by the application to set the ledger signing mode.

The default (weak) implementation returns LedgerSignMode::Dual.

Returns: the desired ledger signing mode

◆ get_wire_nonce()

WireNonce ccf::get_wire_nonce ( const GcmHdr & header )

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

context Access 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
	)

◆ next_tx_if_recovery()

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

inline

◆ parse_svn()

size_t ccf::parse_svn ( const std::string & svn_str )

◆ populate_config_for_join()

void ccf::populate_config_for_join	(	const host::CCHostConfig &	config,
		ccf::StartupConfig &	startup_config
	)

◆ populate_config_for_recover()

void ccf::populate_config_for_recover	(	const host::CCHostConfig &	config,
		ccf::StartupConfig &	startup_config
	)

◆ populate_config_for_start()

void ccf::populate_config_for_start	(	const host::CCHostConfig &	config,
		ccf::StartupConfig &	startup_config
	)

◆ previous_tx_if_recovery()

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

inline

◆ reset_data()

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

inline

◆ resolve_latest_sig_view()

ccf::kv::Term ccf::resolve_latest_sig_view ( ccf::kv::ReadOnlyTx & tx )

inline

◆ run()

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

◆ run_enclave_threads()

void ccf::run_enclave_threads ( const host::CCHostConfig & config )

◆ run_main_loop()

std::optional< size_t > ccf::run_main_loop	(	host::CCHostConfig &	config,
		messaging::BufferProcessor &	buffer_processor,
		ringbuffer::Circuit &	circuit,
		EnclaveConfig &	enclave_config,
		ccf::LoggerLevel	log_level
	)

◆ schema_name() [1/8]

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

inline

◆ schema_name() [2/8]

template<typename FmtExtender >

std::string ccf::schema_name ( const EntityId< FmtExtender > * entity_id_type )

inline

◆ schema_name() [3/8]

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

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

inline

◆ schema_name() [8/8]

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

inline

◆ setup_rpc_interfaces()

void ccf::setup_rpc_interfaces	(	host::CCHostConfig &	config,
		asynchost::RPCConnections< asynchost::TCP > &	rpc,
		asynchost::RPCConnections< asynchost::UDP > &	rpc_udp
	)

◆ 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

◆ validate_and_adjust_recovery_threshold()

void ccf::validate_and_adjust_recovery_threshold ( host::CCHostConfig & config )

◆ validate_issuer()

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

◆ verify_code_transparent_statement()

QuoteVerificationResult ccf::verify_code_transparent_statement	(	ccf::kv::ReadOnlyTx &	tx,
		const std::vector< uint8_t > &	ts_raw,
		const HostData &	host_data,
		std::shared_ptr< NetworkIdentitySubsystemInterface >	network_identity_subsystem
	)

◆ 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,
		std::optional< HostData > &	host_data
	)

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

◆ write_certificates_to_disk()

void ccf::write_certificates_to_disk	(	const host::CCHostConfig &	config,
		const std::vector< uint8_t > &	node_cert,
		const std::vector< uint8_t > &	service_cert
	)

Variable Documentation

◆ MAX_HISTORY_LEN

constexpr int ccf::MAX_HISTORY_LEN = 0

constexpr

◆ SEQNO_UNKNOWN

constexpr SeqNo ccf::SEQNO_UNKNOWN = 0

constexpr

◆ VIEW_UNKNOWN

constexpr View ccf::VIEW_UNKNOWN = 0

constexpr

Namespaces

Classes

Concepts

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

◆ ApplicationProtocol

◆ AuthnPolicies

◆ ByteVector

◆ CACertBundlePEMs

◆ Cert

◆ CodeIDs

◆ CodeUpdatePolicy

◆ CommandHandlerWithJson

◆ CommitCallback

◆ Configuration

◆ ConsensusConfig

◆ Constitution

◆ CoseEndorsementsChain

◆ COSEGovernanceHistory

◆ COSERecentProposals

◆ CoseSignature

◆ CoseSignatures

◆ DID

◆ DynamicEndpoints

◆ ECPublicKey

◆ EncryptedLedgerSecrets

◆ EncryptedLedgerSecretsInfo

◆ EncryptedSealedSharesMap

◆ EncryptedShare

◆ EncryptedSharesMap

◆ EncryptedSubmittedShare

◆ EncryptedSubmittedShares

◆ ExtendedState

◆ Feed

◆ FeedToEndorsementsDataMap

◆ GcmHdr

◆ GovernanceHistory

◆ HandlerJsonParamsAndForward

◆ HistoryTree

◆ http_status

◆ InterpreterFlush

◆ JSEngine

◆ JwtIssuer

◆ JwtIssuers

◆ JwtKeyId

◆ JwtPublicSigningKeysMetadata

◆ JwtPublicSigningKeysMetadataLegacy

◆ LastRecoveryType

◆ LedgerSecretPtr

◆ LedgerSecretsForNodes

◆ LedgerSecretsMap

◆ ListenInterfaceID

◆ LocalSealingNodeIdMap

◆ MemberAcks

◆ MemberCerts

◆ MemberId

◆ MemberInfo

◆ MemberPublicEncryptionKeys

◆ MerkleTxHistory

◆ Module

◆ Modules

◆ ModulesQuickJsBytecode

◆ ModulesQuickJsVersion

◆ MsgNonce

◆ NamedAuthPolicies

◆ Node2NodeMsg

◆ NodeEncryptor

◆ NodeEndorsedCertificates

◆ NodeId

◆ Nodes

◆ Nonce

◆ OpenAPISecuritySchema

◆ PathParams

◆ PreviousServiceIdentity

◆ PreviousServiceIdentityEndorsement

◆ PreviousServiceLastSignedRoot