Type Members

1.  trait AdminServerConfig extends ServerConfig

   A variant of ServerConfig that by default listens to connections only on the loopback interface.

2.  final case class ApiLoggingConfig(messagePayloads: Option[Boolean] = None, maxMethodLength: Int = ApiLoggingConfig.defaultMaxMethodLength, maxMessageLines: Int = ApiLoggingConfig.defaultMaxMessageLines, maxStringLength: Int = ApiLoggingConfig.defaultMaxStringLength, maxMetadataSize: Int = ApiLoggingConfig.defaultMaxMetadataSize, warnBeyondLoad: Option[Int] = ApiLoggingConfig.defaultWarnBeyondLoad) extends Product with Serializable

   Control logging of the ApiRequestLogger

   Control logging of the ApiRequestLogger

   Every GRPC service invocation is logged through the ApiRequestLogger. This allows to monitor all incoming traffic to a node (ledger API, sequencer API, admin API).

   messagePayloads

   Indicates whether to log message payloads. (To be disabled in production!) Also applies to metadata. None is equivalent to false.

   maxMethodLength

   indicates how much to abbreviate the name of the called method. E.g. "com.digitalasset.canton.MyMethod" may get abbreviated to "c.d.c.MyMethod". The last token will never get abbreviated.

   maxMessageLines

   maximum number of lines to log for a message

   maxStringLength

   maximum number of characters to log for a string within a message

   maxMetadataSize

   maximum size of metadata

   warnBeyondLoad

   If API logging is turned on, emit a warning on each request if the load exceeds this threshold.

3.  sealed trait ApiType extends PrettyPrinting
4.  sealed trait BaseTlsArguments extends AnyRef
5.  sealed trait BatchAggregatorConfig extends Product with Serializable

   Parameters for that batcher that batches queries (e.g., to a DB).

6.  final case class BatchingConfig(maxItemsInSqlClause: PositiveNumeric[Int] = BatchingConfig.defaultMaxItemsInSqlClause, parallelism: PositiveNumeric[Int] = BatchingConfig.defaultBatchingParallelism) extends Product with Serializable

   Various settings to control batching behaviour related to db queries

   Various settings to control batching behaviour related to db queries

   maxItemsInSqlClause

   maximum number of items to place in sql "in clauses"

   parallelism

   number of parallel queries to the db. defaults to 8

7.  final case class CacheConfig(maximumSize: PositiveNumeric[Long], expireAfterAccess: NonNegativeFiniteDuration = NonNegativeFiniteDuration.ofMinutes(1)) extends Product with Serializable

   Configurations settings for a single cache

   Configurations settings for a single cache

   maximumSize

   the maximum size of the cache

   expireAfterAccess

   how quickly after last access items should be expired from the cache

8.  final case class CacheConfigWithTimeout(maximumSize: PositiveNumeric[Long], expireAfterTimeout: PositiveFiniteDuration = PositiveFiniteDuration.ofMinutes(10)) extends Product with Serializable

   Configurations settings for a single cache where elements are evicted after a certain time as elapsed (regardless of access).

   Configurations settings for a single cache where elements are evicted after a certain time as elapsed (regardless of access).

   maximumSize

   the maximum size of the cache

   expireAfterTimeout

   how quickly after creation items should be expired from the cache

9.  final case class CachingConfigs(indexedStrings: CacheConfig = CachingConfigs.defaultStaticStringCache, contractStore: CacheConfig = CachingConfigs.defaultContractStoreCache, topologySnapshot: CacheConfig = CachingConfigs.defaultTopologySnapshotCache, partyCache: CacheConfig = CachingConfigs.defaultPartyCache, participantCache: CacheConfig = CachingConfigs.defaultParticipantCache, keyCache: CacheConfig = CachingConfigs.defaultKeyCache, sessionKeyCacheConfig: SessionKeyCacheConfig = CachingConfigs.defaultSessionKeyCacheConfig, packageVettingCache: CacheConfig = CachingConfigs.defaultPackageVettingCache, mySigningKeyCache: CacheConfig = CachingConfigs.defaultMySigningKeyCache, trafficStatusCache: CacheConfig = CachingConfigs.defaultTrafficStatusCache, memberCache: CacheConfig = CachingConfigs.defaultMemberCache, kmsMetadataCache: CacheConfig = CachingConfigs.kmsMetadataCache, finalizedMediatorRequests: CacheConfig = CachingConfigs.defaultFinalizedMediatorRequestsCache) extends Product with Serializable

   Configuration settings for various internal caches

   Configuration settings for various internal caches

   indexedStrings

   cache size configuration for the static string index cache

   contractStore

   cache size configuration for the contract store

   topologySnapshot

   cache size configuration for topology snapshots

   finalizedMediatorRequests

   cache size for the finalized mediator requests such the mediator does not have to perform a db round-trip if we have slow responders.

10.  final case class CantonCommunityConfig(domains: Map[InstanceName, CommunityDomainConfig] = Map.empty, participants: Map[InstanceName, CommunityParticipantConfig] = Map.empty, remoteDomains: Map[InstanceName, RemoteDomainConfig] = Map.empty, remoteParticipants: Map[InstanceName, RemoteParticipantConfig] = Map.empty, monitoring: MonitoringConfig = MonitoringConfig(), parameters: CantonParameters = CantonParameters(), features: CantonFeatures = CantonFeatures()) extends CantonConfig with ConfigDefaults[DefaultPorts, CantonCommunityConfig] with Product with Serializable
11.  trait CantonConfig extends AnyRef

    Root configuration parameters for a single Canton process.

12.  final case class CantonEnterpriseConfig(sequencers: Map[InstanceName, SequencerNodeConfig] = Map.empty, domains: Map[InstanceName, EnterpriseDomainConfig] = Map.empty, domainManagers: Map[InstanceName, DomainManagerConfig] = Map.empty, mediators: Map[InstanceName, MediatorNodeConfig] = Map.empty, participants: Map[InstanceName, EnterpriseParticipantConfig] = Map.empty, remoteSequencers: Map[InstanceName, RemoteSequencerConfig] = Map.empty, remoteMediators: Map[InstanceName, RemoteMediatorConfig] = Map.empty, remoteDomains: Map[InstanceName, RemoteDomainConfig] = Map.empty, remoteDomainManagers: Map[InstanceName, RemoteDomainManagerConfig] = Map.empty, remoteParticipants: Map[InstanceName, RemoteParticipantConfig] = Map.empty, monitoring: MonitoringConfig = MonitoringConfig(), parameters: CantonParameters = CantonParameters(), features: CantonFeatures = CantonFeatures()) extends CantonConfig with ConfigDefaults[DefaultPorts, CantonEnterpriseConfig] with Product with Serializable
13.  final case class CantonFeatures(enablePreviewCommands: Boolean = false, enableTestingCommands: Boolean = false, enableRepairCommands: Boolean = false, skipTopologyManagerSignatureValidation: Boolean = false) extends Product with Serializable

    Control which features are turned on / off in Canton

    Control which features are turned on / off in Canton

    enablePreviewCommands

    Feature flag to enable the set of commands that use functionality which we don't deem stable.

    enableTestingCommands

    Feature flag to enable the set of commands used by Canton developers for testing purposes.

    enableRepairCommands

    Feature flag to enable the set of commands used by Canton operators for manual repair purposes.

    skipTopologyManagerSignatureValidation

    If true, the signature validation of the domain topology transaction messages (2.x) will be skipped

14.  final case class CantonParameters(clock: ClockConfig = ClockConfig.WallClock(), enableAdditionalConsistencyChecks: Boolean = false, manualStart: Boolean = false, startupParallelism: Option[PositiveInt] = None, nonStandardConfig: Boolean = false, devVersionSupport: Boolean = false, betaVersionSupport: Boolean = false, portsFile: Option[String] = None, timeouts: TimeoutSettings = TimeoutSettings(), retentionPeriodDefaults: RetentionPeriodDefaults = RetentionPeriodDefaults(), console: AmmoniteConsoleConfig = AmmoniteConsoleConfig(), exitOnFatalFailures: Boolean = true) extends Product with Serializable

    Parameters for testing Canton.

    Parameters for testing Canton. Use default values in a production environment.

    enableAdditionalConsistencyChecks

    if true, run additional consistency checks. This will degrade performance.

    manualStart

    If set to true, the nodes have to be manually started via console (default false)

    startupParallelism

    Start up to N nodes in parallel (default is num-threads)

    nonStandardConfig

    don't fail config validation on non-standard configuration settings

    devVersionSupport

    If true, allow domain nodes to use unstable protocol versions and participant nodes to connect to such domains

    betaVersionSupport

    If true, allow domain nodes to use beta protocol versions and participant nodes to connect to such domains

    portsFile

    A ports file name, where the ports of all participants will be written to after startup

    timeouts

    Sets the timeouts used for processing and console

    exitOnFatalFailures

    If true the node will exit/stop the process in case of fatal failures

15.  sealed trait CheckConfig extends AnyRef

    Configuration for a check

16.  final case class ClientConfig(address: String = "127.0.0.1", port: Port, tls: Option[TlsClientConfig] = None, keepAliveClient: Option[KeepAliveClientConfig] = Some(KeepAliveClientConfig())) extends Product with Serializable

    A client configuration to a corresponding server configuration

17.  sealed trait ClockConfig extends Product with Serializable
18.  final case class CommunityAdminServerConfig(address: String = defaultAddress, internalPort: Option[Port] = None, tls: Option[TlsServerConfig] = None, keepAliveServer: Option[KeepAliveServerConfig] = Some(KeepAliveServerConfig()), maxInboundMessageSize: NonNegativeInt = ServerConfig.defaultMaxInboundMessageSize) extends AdminServerConfig with CommunityServerConfig with Product with Serializable
19.  final case class CommunityCryptoConfig(provider: CommunityCryptoProvider = CommunityCryptoProvider.Tink, signing: CryptoSchemeConfig[SigningKeyScheme] = CryptoSchemeConfig(), encryption: CryptoSchemeConfig[EncryptionKeyScheme] = CryptoSchemeConfig(), symmetric: CryptoSchemeConfig[SymmetricKeyScheme] = CryptoSchemeConfig(), hash: CryptoSchemeConfig[HashAlgorithm] = CryptoSchemeConfig()) extends CryptoConfig with Product with Serializable
20.  sealed trait CommunityCryptoProvider extends CryptoProvider
21.  sealed trait CommunityDbConfig extends CommunityStorageConfig with DbConfig
22.  trait CommunityLocalNodeConfig extends LocalNodeConfig
23.  trait CommunityServerConfig extends ServerConfig
24.  sealed trait CommunityStorageConfig extends StorageConfig

    Determines how a node stores persistent data.

25.  sealed trait ConcurrencyLimitConfig extends AnyRef

    Use Netflix's https://github.com/Netflix/concurrency-limits to cap the number of concurrent requests.

26.  class ConfidentialConfigWriter extends AnyRef
27.  trait ConfigDefaults[Defaults, Self] extends AnyRef
28.  final case class ConnectionAllocation(numReads: Option[PositiveInt] = None, numWrites: Option[PositiveInt] = None, numLedgerApi: Option[PositiveInt] = None) extends PrettyPrinting with Product with Serializable
29.  final case class ConsoleCommandTimeout(bounded: NonNegativeDuration = ConsoleCommandTimeout.defaultBoundedTimeout, unbounded: NonNegativeDuration = ConsoleCommandTimeout.defaultUnboundedTimeout, ledgerCommand: NonNegativeDuration = ConsoleCommandTimeout.defaultLedgerCommandsTimeout, ping: NonNegativeDuration = ConsoleCommandTimeout.defaultPingTimeout, testingBong: NonNegativeDuration = ConsoleCommandTimeout.defaultTestingBongTimeout) extends Product with Serializable

    Configuration for console command timeouts

    Configuration for console command timeouts

    bounded

    timeout on how long "bounded" operations, i.e. operations which normally are supposed to conclude in a fixed timeframe can run before the console considers them as failed.

    unbounded

    timeout on how long "unbounded" operations can run, potentially infinite.

    ledgerCommand

    default timeout used for ledger commands

    ping

    default ping timeout

    testingBong

    default bong timeout

30.  trait CryptoConfig extends AnyRef

    Cryptography configuration.

31.  trait CryptoProvider extends PrettyPrinting
32.  final case class CryptoProviderScheme[S](default: S, supported: NonEmpty[Set[S]]) extends Product with Serializable
33.  final case class CryptoSchemeConfig[S](default: Option[S] = None, allowed: Option[NonEmpty[Set[S]]] = None) extends Product with Serializable

    Configures the optional default and allowed schemes of kind S.

    Configures the optional default and allowed schemes of kind S.

    default

    The optional scheme to use. If none is specified, use the provider's default scheme of kind S.

    allowed

    The optional allowed schemes to use. If none is specified, all the provider's supported schemes of kind S are allowed.

34.  final case class DbCacheConfig(maximumCacheSize: PositiveNumeric[Long] = DbCacheConfig.defaultMaximumCacheSize) extends Product with Serializable

    Parameters for the in-memory cache that can be used in front of a db-based data provider.

    Parameters for the in-memory cache that can be used in front of a db-based data provider.

    maximumCacheSize

    Maximum number of elements of the cache.

35.  trait DbConfig extends StorageConfig with PrettyPrinting

    Dictates that persistent data is stored in a database.

36.  final case class DbLockConfig(healthCheckPeriod: PositiveFiniteDuration = PositiveFiniteDuration.ofSeconds(5), healthCheckTimeout: PositiveFiniteDuration = PositiveFiniteDuration.ofSeconds(15)) extends Product with Serializable

    Configuration of a DB lock

    Configuration of a DB lock

    healthCheckPeriod

    Health check period, i.e., how long to wait between one health check completed and the next to start.

    healthCheckTimeout

    Timeout for running a health check in seconds granularity.

37.  final case class DbLockedConnectionConfig(passiveCheckPeriod: PositiveFiniteDuration = PositiveFiniteDuration.ofSeconds(15), healthCheckPeriod: PositiveFiniteDuration = PositiveFiniteDuration.ofSeconds(5), healthCheckTimeout: PositiveFiniteDuration = PositiveFiniteDuration.ofSeconds(15), connectionTimeout: PositiveFiniteDuration = PositiveFiniteDuration.ofSeconds(10), keepAliveIdle: Option[PositiveFiniteDuration] = None, keepAliveInterval: Option[PositiveFiniteDuration] = None, keepAliveCount: Option[Int] = None, initialAcquisitionMaxRetries: Int = 5, initialAcquisitionInterval: PositiveFiniteDuration = PositiveFiniteDuration.ofMillis(200), lock: DbLockConfig = DbLockConfig()) extends Product with Serializable

    Configuration of a DB-locked connection, i.e., a database connection with an associated DB lock.

    Configuration of a DB-locked connection, i.e., a database connection with an associated DB lock.

    passiveCheckPeriod

    How long to wait between trying to become active.

    healthCheckPeriod

    Health check period, i.e., how long to wait between one health check completed and the next to start.

    healthCheckTimeout

    Timeout for running a health check in seconds granularity.

    connectionTimeout

    Timeout for requesting a new connection from the underlying database driver in seconds granularity.

    keepAliveIdle

    TCP keep-alive idle time, i.e., how long to wait until sending a keep-alive message when idle.

    keepAliveInterval

    TCP keep-alive interval, i.e., how long to wait until resending an unanswered keep-alive message.

    keepAliveCount

    TCP keep-alive count, i.e., how many unanswered keep-alive messages required to consider the connection lost.

    initialAcquisitionMaxRetries

    Maximum number of retries when trying to acquire the lock for the first time before trying to acquire the lock in a background task.

    initialAcquisitionInterval

    Retry intervals during the initial attempts to acquire the lock.

    lock

    Configuration of the DB locks used by the pool.

38.  final case class DbLockedConnectionPoolConfig(healthCheckPeriod: PositiveFiniteDuration = PositiveFiniteDuration.ofSeconds(5), connection: DbLockedConnectionConfig = DbLockedConnectionConfig(), activeTimeout: PositiveFiniteDuration = PositiveFiniteDuration.ofSeconds(15)) extends Product with Serializable

    Configuration for the connection pool using DB locks.

    Configuration for the connection pool using DB locks.

    healthCheckPeriod

    Health check period, i.e., how long to wait between health checks of the connection pool.

    connection

    Configuration of the DB locked connection used by the pool.

    activeTimeout

    Time to wait until the first connection in the pool becomes active during failover.

39.  final case class DbParametersConfig(maxConnections: Option[Int] = None, connectionAllocation: ConnectionAllocation = ConnectionAllocation(), failFastOnStartup: Boolean = true, migrationsPaths: Seq[String] = Seq.empty, ledgerApiJdbcUrl: Option[String] = None, connectionTimeout: NonNegativeFiniteDuration = DbConfig.defaultConnectionTimeout, warnOnSlowQuery: Option[PositiveFiniteDuration] = None, warnOnSlowQueryInterval: PositiveFiniteDuration = DbParametersConfig.defaultWarnOnSlowQueryInterval, unsafeCleanOnValidationError: Boolean = false, unsafeBaselineOnMigrate: Boolean = false, migrateAndStart: Boolean = false) extends PrettyPrinting with Product with Serializable

    Various database related settings

    Various database related settings

    maxConnections

    Allows for setting the maximum number of db connections used by Canton and the ledger API server. If None or non-positive, the value will be auto-detected from the number of processors. Has no effect, if the number of connections is already set via slick options (i.e., config.numThreads).

    connectionAllocation

    Overrides for the sizes of the connection pools managed by a canton node.

    failFastOnStartup

    If true, the node will fail-fast when the database cannot be connected to If false, the node will wait indefinitely for the database to come up

    migrationsPaths

    Where should database migrations be read from. Enables specialized DDL for different database servers (e.g. Postgres, Oracle).

    ledgerApiJdbcUrl

    Canton attempts to generate appropriate configuration for the daml ledger-api to persist the data it requires. In most circumstances this should be sufficient and there is no need to override this. However if this generation fails or an advanced configuration is required, the ledger-api jdbc url can be explicitly configured using this property. The jdbc url **must** specify the schema of ledger_api (using h2 parameter schema or postgres parameter currentSchema). This property is not used by a domain node as it does not run a ledger-api instance, and will be ignored if the node is configured with in-memory persistence.

    connectionTimeout

    How long to wait for acquiring a database connection

    warnOnSlowQuery

    Optional time when we start logging a query as slow.

    warnOnSlowQueryInterval

    How often to repeat the logging statement for slow queries.

    unsafeCleanOnValidationError

    TO BE USED ONLY FOR TESTING! Clean the database if validation during DB migration fails.

    unsafeBaselineOnMigrate

    TO BE USED ONLY FOR TESTING! Whether to automatically call baseline when migrate is executed against a non-empty schema with no schema history table. This schema will then be baselined with the baselineVersion before executing the migrations. Only migrations above baselineVersion will then be applied. This is useful for databases projects where the initial vendor schema is not empty If baseline should be called on migrate for non-empty schemas, { @code false} if not. (default: { @code false})

    migrateAndStart

    if true, db migrations will be applied to the database (default is to abort start if db migrates are pending to force an explicit updgrade)

40.  final case class DeadlockDetectionConfig(enabled: Boolean = true, interval: NonNegativeFiniteDuration = NonNegativeFiniteDuration.ofSeconds(3), warnInterval: NonNegativeFiniteDuration = NonNegativeFiniteDuration.ofSeconds(10)) extends Product with Serializable

    Deadlock detection configuration

    Deadlock detection configuration

    A simple deadlock detection method. Using a background scheduler, we schedule a trivial future on the EC. If the Future is not executed until we check again, we alert.

    enabled

    if true, we'll monitor the EC for deadlocks (or slow processings)

    interval

    how often we check the EC

    warnInterval

    how often we report a deadlock as still being active

41.  class DefaultPorts extends AnyRef
42.  final case class DomainTimeTrackerConfig(observationLatency: NonNegativeFiniteDuration = DomainTimeTrackerConfig.defaultObservationLatency, patienceDuration: NonNegativeFiniteDuration = DomainTimeTrackerConfig.defaultPatienceDuration, minObservationDuration: NonNegativeFiniteDuration = DomainTimeTrackerConfig.defaultMinObservationDuration, timeRequest: TimeProofRequestConfig = TimeProofRequestConfig()) extends PrettyPrinting with Product with Serializable

    Configuration for the domain time tracker.

    Configuration for the domain time tracker.

    observationLatency

    Even if the host and domain clocks are perfectly synchronized there will always be some latency for an event to be delivered (storage, transmission, processing). If the current host time exceeds the next expected timestamp by this observation latency then we will request a time proof (unless we have received a recent event within the patience duration described below).

    patienceDuration

    We will only request a time proof if this given duration has elapsed since we last received an event (measured using the host clock). This prevents requesting timestamps when we are observing events from the domain (particularly if the local node is catching up on old activity).

    minObservationDuration

    We will try to ensure that we receive a time at least once during this duration (measured using the host clock). This is practically useful if there is no other activity on the domain as the sequencer client will then have an event to acknowledge allowing sequenced events to be pruned before this point. We may in the future use this to monitor clock skews between the host and domain.

    timeRequest

    configuration for how we ask for a time proof.

43.  sealed trait EncryptedPrivateStoreConfig extends AnyRef

    Encapsulates possible configurations for different encrypted private stores

44.  final case class EnterpriseAdminServerConfig(address: String = AdminServerConfig.defaultAddress, internalPort: Option[Port] = None, tls: Option[TlsServerConfig] = None, keepAliveServer: Option[KeepAliveServerConfig] = Some(KeepAliveServerConfig()), maxInboundMessageSize: NonNegativeInt = ServerConfig.defaultMaxInboundMessageSize, concurrencyLimit: Option[ConcurrencyLimitConfig] = None) extends AdminServerConfig with EnterpriseServerConfig with Product with Serializable
45.  final case class EnterpriseCryptoConfig(provider: EnterpriseCryptoProvider = EnterpriseCryptoProvider.Tink, signing: CryptoSchemeConfig[SigningKeyScheme] = CryptoSchemeConfig(), encryption: CryptoSchemeConfig[EncryptionKeyScheme] = CryptoSchemeConfig(), symmetric: CryptoSchemeConfig[SymmetricKeyScheme] = CryptoSchemeConfig(), hash: CryptoSchemeConfig[HashAlgorithm] = CryptoSchemeConfig(), kms: Option[KmsConfig] = None, privateKeyStore: PrivateKeyStoreConfig = PrivateKeyStoreConfig()) extends CryptoConfig with Product with Serializable

    Defines an enterprise crypto configuration with two new configurations kms and privateKeyStore.

    Defines an enterprise crypto configuration with two new configurations kms and privateKeyStore.

    kms

    defines a KMS client configuration (e.g. Aws)

    privateKeyStore

    define the type of a private key store

46.  sealed trait EnterpriseCryptoProvider extends CryptoProvider
47.  sealed trait EnterpriseDbConfig[A <: EnterpriseDbConfig[A]] extends EnterpriseStorageConfig with DbConfig
48.  trait EnterpriseLocalNodeConfig extends LocalNodeConfig
49.  trait EnterpriseServerConfig extends ServerConfig
50.  sealed trait EnterpriseStorageConfig extends StorageConfig
51.  final case class FixedLimit(limit: Int) extends LimitConfig with Product with Serializable

    A constant concurrency limit.

52.  final case class Gradient2Limit(maxConcurrency: Option[Int], smoothing: Option[Double], rttTolerance: Option[Double]) extends LimitConfig with Product with Serializable

    Gradient-based algorithm to estimate the ideal limit.

    Gradient-based algorithm to estimate the ideal limit.

    https://javadoc.io/static/com.netflix.concurrency-limits/concurrency-limits-core/0.3.6/com/netflix/concurrency/limits/limit/Gradient2Limit.html

53.  final case class GrpcHealthServerConfig(address: String = "0.0.0.0", internalPort: Option[Port] = None, keepAliveServer: Option[KeepAliveServerConfig] = Some(KeepAliveServerConfig()), parallelism: Int = 4) extends ServerConfig with Product with Serializable

    Configuration of the gRPC health server for a canton node.

    Configuration of the gRPC health server for a canton node.

    parallelism

    number of threads to be used in the gRPC server

54.  trait H2DbConfig extends DbConfig
55.  final case class HealthConfig(server: HealthServerConfig, check: CheckConfig) extends Product with Serializable

    Configuration to expose a health endpoint on the given server running the configured check

    Configuration to expose a health endpoint on the given server running the configured check

    server

    Server details for hosting the health endpoint

    check

    Check for determining whether this canton process is healthy

56.  final case class HealthServerConfig(address: String = "0.0.0.0", port: Port) extends Product with Serializable

    Configuration of health server backend.

57.  final case class InitConfig(identity: Option[Identity] = None) extends InitConfigBase with Product with Serializable

    Configuration for the node's init process

    Configuration for the node's init process

    identity

    Controls how the node identity (prefix of the unique identifier) is determined

58.  trait InitConfigBase extends AnyRef
59.  final case class KeepAliveClientConfig(time: NonNegativeFiniteDuration = NonNegativeFiniteDuration.ofSeconds(40), timeout: NonNegativeFiniteDuration = NonNegativeFiniteDuration.ofSeconds(20)) extends Product with Serializable

    GRPC keep alive client configuration

    GRPC keep alive client configuration

    Settings according to https://grpc.github.io/grpc-java/javadoc/io/grpc/ManagedChannelBuilder.html#keepAliveTime-long-java.util.concurrent.TimeUnit-

    time

    Sets the time without read activity before sending a keepalive ping. Do not set to small numbers (default is 40s)

    timeout

    Sets the time waiting for read activity after sending a keepalive ping (default is 20s)

60.  final case class KeepAliveServerConfig(time: NonNegativeFiniteDuration = NonNegativeFiniteDuration.ofSeconds(40), timeout: NonNegativeFiniteDuration = NonNegativeFiniteDuration.ofSeconds(20), permitKeepAliveTime: NonNegativeFiniteDuration = NonNegativeFiniteDuration.ofSeconds(20)) extends Product with Serializable

    GRPC keep alive server configuration

    GRPC keep alive server configuration

    time

    Sets the time without read activity before sending a keepalive ping. Do not set to small numbers (default is 40s) Corresponds to https://grpc.github.io/grpc-java/javadoc/io/grpc/netty/NettyServerBuilder.html#keepAliveTime-long-java.util.concurrent.TimeUnit-

    timeout

    Sets the time waiting for read activity after sending a keepalive ping (default is 20s) Corresponds to https://grpc.github.io/grpc-java/javadoc/io/grpc/netty/NettyServerBuilder.html#keepAliveTimeout-long-java.util.concurrent.TimeUnit-

    permitKeepAliveTime

    Sets the most aggressive keep-alive time that clients are permitted to configure (default is 20s) Corresponds to https://grpc.github.io/grpc-java/javadoc/io/grpc/netty/NettyServerBuilder.html#permitKeepAliveTime-long-java.util.concurrent.TimeUnit-

61.  final case class KeyStoreConfig(path: File, password: Password) extends Product with Serializable

    Configuration for Java keystore with optional password protection.

62.  class KeyStoreConfigWriters extends AnyRef

    Annotations

    @nowarn()

63.  sealed trait KmsConfig extends AnyRef

    Encapsulates configurations for different KMS

64.  sealed trait LimitConfig extends ConcurrencyLimitConfig

    Corresponds to https://javadoc.io/doc/com.netflix.concurrency-limits/concurrency-limits-core/latest/com/netflix/concurrency/limits/Limit.html

65.  trait LocalNodeConfig extends NodeConfig
66.  trait LocalNodeParametersConfig extends AnyRef
67.  final case class LoggingConfig(api: ApiLoggingConfig = ApiLoggingConfig(), eventDetails: Boolean = false, logConfigOnStartup: Boolean = true, logConfigWithDefaults: Boolean = false) extends Product with Serializable

    Detailed logging configurations

    Detailed logging configurations

    This section allows to configure additional data such as transaction details to be logged to the standard logback system

    api

    Configuration settings for the ApiRequestLogger

    eventDetails

    If set to true, we will log substantial details of internal messages being processed. To be disabled in production!

    logConfigOnStartup

    If set to true (default), it will log the config on startup (omitting sensitive details)

    logConfigWithDefaults

    If set to true (default false), the default values of the config will be included

68.  trait MemoryStorageConfig extends StorageConfig
69.  final case class MonitoringConfig(deadlockDetection: DeadlockDetectionConfig = DeadlockDetectionConfig(), health: Option[HealthConfig] = None, metrics: MetricsConfig = MetricsConfig(), delayLoggingThreshold: NonNegativeFiniteDuration = MonitoringConfig.defaultDelayLoggingThreshold, tracing: TracingConfig = TracingConfig(), logMessagePayloads: Option[Boolean] = None, logQueryCost: Option[QueryCostMonitoringConfig] = None, logSlowFutures: Boolean = false, healthDumpMetricFrequency: NonNegativeFiniteDuration = MonitoringConfig.defaultHealthDumpMetricFrequency, logging: LoggingConfig = LoggingConfig(), dumpNumRollingLogFiles: NonNegativeInt = MonitoringConfig.defaultDumpNumRollingLogFiles) extends LazyLogging with Product with Serializable

    Configuration for metrics and tracing

    Configuration for metrics and tracing

    deadlockDetection

    Should we regularly check our environment EC for deadlocks?

    health

    Optional Health check to expose an http server to monitor is the canton process is healthy

    metrics

    Optional Metrics Reporter used to expose internally captured metrics

    delayLoggingThreshold

    Logs a warning message once the sequencer client falls behind in processing messages from the sequencer (based on the sequencing timestamp).

    tracing

    Tracing configuration

    logMessagePayloads

    Determines whether message payloads (as well as metadata) sent through GRPC are logged.

    logQueryCost

    Determines whether to log the 15 most expensive db queries

    logSlowFutures

    Whether we should active log slow futures (where instructed)

    dumpNumRollingLogFiles

    How many of the rolling log files shold be included in the remote dump. Default is 0.

70.  trait NodeConfig extends AnyRef
71.  final case class NodeMonitoringConfig(grpcHealthServer: Option[GrpcHealthServerConfig] = None) extends Product with Serializable

    Monitoring configuration for a canton node.

    Monitoring configuration for a canton node.

    grpcHealthServer

    Optional gRPC Health server configuration

72.  final case class NonNegativeDuration(duration: Duration) extends RefinedNonNegativeDuration[NonNegativeDuration] with Product with Serializable

    Duration class used for non-negative durations.

    Duration class used for non-negative durations.

    There are two options: either it's a non-negative duration or an infinite duration

73.  final case class NonNegativeFiniteDuration(underlying: FiniteDuration) extends RefinedNonNegativeDuration[NonNegativeFiniteDuration] with Product with Serializable

    Duration class used for non-negative finite durations.

74.  final case class Password(pw: String) extends AnyVal with Product with Serializable

    Password wrapper for keystores to prevent the values being printed in logs.

    Password wrapper for keystores to prevent the values being printed in logs.

    pw

    password value - public for supporting PureConfig parsing but callers should prefer accessing through unwrap

75.  final case class PositiveDurationSeconds(underlying: FiniteDuration) extends RefinedNonNegativeDuration[PositiveDurationSeconds] with Product with Serializable

    Duration class used for positive durations that are rounded to the second.

76.  final case class PositiveFiniteDuration(underlying: FiniteDuration) extends RefinedNonNegativeDuration[PositiveFiniteDuration] with Product with Serializable

    Duration class used for positive finite durations.

77.  trait PostgresDbConfig extends DbConfig
78.  final case class PrivateKeyStoreConfig(encryption: Option[EncryptedPrivateStoreConfig] = None) extends Product with Serializable

    Stores the configuration for a private store

    Stores the configuration for a private store

    encryption

    flags that the store is encrypted with a specific encryption approach. The default value is None which means unencrypted.

79.  final case class ProcessingTimeout(unbounded: NonNegativeDuration = DefaultProcessingTimeouts.unbounded, io: NonNegativeDuration = DefaultProcessingTimeouts.io, default: NonNegativeDuration = DefaultProcessingTimeouts.default, network: NonNegativeDuration = DefaultProcessingTimeouts.network, shutdownProcessing: NonNegativeDuration = DefaultProcessingTimeouts.shutdownProcessing, shutdownNetwork: NonNegativeDuration = DefaultProcessingTimeouts.shutdownNetwork, shutdownShort: NonNegativeDuration = DefaultProcessingTimeouts.shutdownShort, closing: NonNegativeDuration = DefaultProcessingTimeouts.closing, inspection: NonNegativeDuration = DefaultProcessingTimeouts.inspection, storageMaxRetryInterval: NonNegativeDuration = DefaultProcessingTimeouts.maxRetryInterval, verifyActive: NonNegativeDuration = DefaultProcessingTimeouts.verifyActive, activeInit: NonNegativeDuration = DefaultProcessingTimeouts.activeInit, slowFutureWarn: NonNegativeDuration = DefaultProcessingTimeouts.slowFutureWarn, activeInitRetryDelay: NonNegativeDuration = DefaultProcessingTimeouts.activeInitRetryDelay, sequencerInfo: NonNegativeDuration = DefaultProcessingTimeouts.sequencerInfo, topologyDispatching: NonNegativeDuration = DefaultProcessingTimeouts.topologyDispatching) extends Product with Serializable

    Configuration for internal await timeouts

    Configuration for internal await timeouts

    unbounded

    timeout on how long "unbounded" operations can run. should be infinite in theory.

    io

    timeout for disk based operations

    default

    default finite processing timeout

    network

    timeout for things related to networking

    shutdownProcessing

    timeout used for shutdown of some processing where we'd like to keep the result (long)

    shutdownNetwork

    timeout used for shutdown where we interact with some remote system

    shutdownShort

    everything else shutdown releated (default)

    closing

    our closing time (which should be strictly larger than any of the shutdown values)

    inspection

    timeout for the storage inspection commands (can run a long long time)

    storageMaxRetryInterval

    max retry interval for storage

    verifyActive

    how long should we wait for the domain to tell us whether we are active or not

    activeInit

    how long a passive replica should wait for the initialization by the active replica

    slowFutureWarn

    when using future supervision, when should we start to warn about a slow future

    activeInitRetryDelay

    delay between attempts while waiting for initialization of the active replica

    sequencerInfo

    how long are we going to try to get the sequencer connection information. setting this high means that connect calls will take quite a while if one of the sequencers is offline.

    topologyDispatching

    how long we wait for the topology to retry the dispatching of a message

80.  trait ProtocolConfig extends AnyRef
81.  final case class QueryCostMonitoringConfig(every: NonNegativeFiniteDuration, resetOnOutput: Boolean = true, logOperations: Boolean = false) extends Product with Serializable

    Configuration for monitoring the cost of db queries.

    Configuration for monitoring the cost of db queries.

    every

    determines the duration between reports

    resetOnOutput

    determines whether the statistics will be reset after creating a report

    logOperations

    if true (default false), log every query operation

82.  trait RefinedNonNegativeDuration[D <: RefinedNonNegativeDuration[D]] extends PrettyPrinting
83.  trait RefinedNonNegativeDurationCompanion[D <: RefinedNonNegativeDuration[D]] extends AnyRef
84.  final case class ReplicationConfig(enabled: Option[Boolean] = None, connectionPool: DbLockedConnectionPoolConfig = DbLockedConnectionPoolConfig()) extends Product with Serializable

    Configuration of node replication for high availability

    Configuration of node replication for high availability

    enabled

    Needs to be set to true for a replicated node, which shares the database with other replicas.

    connectionPool

    Configuration for the write connection pool.

85.  final case class RetentionPeriodDefaults(sequencer: NonNegativeFiniteDuration = NonNegativeFiniteDuration.ofDays(7), mediator: NonNegativeFiniteDuration = NonNegativeFiniteDuration.ofDays(7), unauthenticatedMembers: NonNegativeFiniteDuration = NonNegativeFiniteDuration.ofHours(1)) extends Product with Serializable

    Default retention periods used by pruning commands where no values are explicitly specified.

    Default retention periods used by pruning commands where no values are explicitly specified. Although by default the commands will retain enough data to remain operational, however operators may like to retain more than this to facilitate possible disaster recovery scenarios or retain evidence of completed transactions.

86.  sealed trait SequencerConnectionConfig extends AnyRef

    Definition provided by the domain node to members with details on how to connect to the domain sequencer.

    Definition provided by the domain node to members with details on how to connect to the domain sequencer. *

87.  sealed trait ServerAuthRequirementConfig extends AnyRef

    Configuration on whether server requires auth, requests auth, or no auth

88.  trait ServerConfig extends Product with Serializable

    Configuration for hosting a server api

89.  final case class SessionKeyCacheConfig(enabled: Boolean, senderCache: CacheConfigWithTimeout, receiverCache: CacheConfigWithTimeout) extends Product with Serializable

    Configuration settings for a cache that stores: (a) the public asymmetric encryptions of the session keys for the sender and (b) the decrypting results in the receiver.

    Configuration settings for a cache that stores: (a) the public asymmetric encryptions of the session keys for the sender and (b) the decrypting results in the receiver. This reduces the amount of asymmetric operations that need to to be performed for each of the views that share the same participant recipient group (i.e. use the same session key).

    enabled

    enable/disable caching of the session key. Caching is enabled by default, offering a trade-off between secrecy and performance

    senderCache

    configuration for the sender's cache that stores the encryptions of the session keys

    receiverCache

    configuration for the receiver's cache that stores the decryptions of the session keys

90.  trait StorageConfig extends AnyRef
91.  final case class TestSequencerClientFor(environmentId: String, memberName: String, domainName: String) extends Product with Serializable
    environmentId

    ID used to disambiguate tests running in parallel

    memberName

    The name of the member that should use a delayed sequencer client

    domainName

    The name of the domain for which the member should use a delayed sequencer client

92.  final case class TestingConfigInternal(testSequencerClientFor: Set[TestSequencerClientFor] = Set.empty, metricsFactoryType: MetricsFactoryType = External, initializeGlobalOpenTelemetry: Boolean = true, doNotUseCommitmentCachingFor: Set[Identifier] = Set.empty) extends Product with Serializable

    Used to set parameters for testing when these don't need to be exposed in a config file.

    Used to set parameters for testing when these don't need to be exposed in a config file.

    initializeGlobalOpenTelemetry

    Determines whether the OpenTelemetry instance we build is set as the global OpenTelemetry instance. This is set to false during tests to prevent failures as the global OpenTelemetry instance can be initialized just once.

93.  final case class TimeProofRequestConfig(initialRetryDelay: NonNegativeFiniteDuration = TimeProofRequestConfig.defaultInitialRetryDelay, maxRetryDelay: NonNegativeFiniteDuration = TimeProofRequestConfig.defaultMaxRetryDelay, maxSequencingDelay: NonNegativeFiniteDuration = TimeProofRequestConfig.defaultMaxSequencingDelay) extends PrettyPrinting with Product with Serializable
    initialRetryDelay

    The initial retry delay if the request to send a sequenced event fails

    maxRetryDelay

    The max retry delay if the request to send a sequenced event fails

    maxSequencingDelay

    If our request for a sequenced event was successful, how long should we wait to observe it from the sequencer before starting a new request.

94.  final case class TimeoutSettings(console: ConsoleCommandTimeout = ConsoleCommandTimeout(), processing: ProcessingTimeout = ProcessingTimeout()) extends Product with Serializable

    Timeout settings configuration

95.  final case class TlsBaseServerConfig(certChainFile: ExistingFile, privateKeyFile: ExistingFile, minimumServerProtocolVersion: Option[String] = Some( TlsServerConfig.defaultMinimumServerProtocol ), ciphers: Option[Seq[String]] = TlsServerConfig.defaultCiphers) extends BaseTlsArguments with Product with Serializable

    A wrapper for TLS server parameters supporting only server side authentication

    A wrapper for TLS server parameters supporting only server side authentication

    Same parameters as the more complete TlsServerConfig

96.  final case class TlsClientCertificate(certChainFile: File, privateKeyFile: File) extends Product with Serializable

97.  final case class TlsClientConfig(trustCollectionFile: Option[ExistingFile], clientCert: Option[TlsClientCertificate]) extends Product with Serializable

    A wrapper for TLS related client configurations

    A wrapper for TLS related client configurations

    trustCollectionFile

    a file containing certificates of all nodes the client trusts. If none is specified, defaults to the JVM trust store

    clientCert

    the client certificate

98.  final case class TlsServerConfig(certChainFile: ExistingFile, privateKeyFile: ExistingFile, trustCollectionFile: Option[ExistingFile] = None, secretsUrl: Option[String] = None, clientAuth: ServerAuthRequirementConfig = ServerAuthRequirementConfig.Optional, minimumServerProtocolVersion: Option[String] = Some( TlsServerConfig.defaultMinimumServerProtocol ), ciphers: Option[Seq[String]] = TlsServerConfig.defaultCiphers, enableCertRevocationChecking: Boolean = false) extends BaseTlsArguments with Product with Serializable

    A wrapper for TLS related server parameters supporting mutual authentication.

    A wrapper for TLS related server parameters supporting mutual authentication.

    Certificates and keys must be provided in the PEM format. It is recommended to create them with OpenSSL. Other formats (such as GPG) may also work, but have not been tested.

    certChainFile

    a file containing a certificate chain, containing the certificate chain from the server to the root CA. The certificate chain is used to authenticate the server. The order of certificates in the chain matters, i.e., it must start with the server certificate and end with the root certificate.

    privateKeyFile

    a file containing the server's private key. The key must not use a password.

    trustCollectionFile

    a file containing certificates of all nodes the server trusts. Used for client authentication. It depends on the enclosing configuration whether client authentication is mandatory, optional or unsupported. If client authentication is enabled and this parameter is absent, the certificates in the JVM trust store will be used instead.

    secretsUrl

    URL of a secrets service that provide parameters needed to decrypt the private key. Required when private key is encrypted (indicated by '.enc' filename suffix).

    clientAuth

    indicates whether server requires, requests, does does not request auth from clients. Normally the ledger api server requires client auth under TLS, but using this setting this requirement can be loosened. See https://github.com/digital-asset/daml/commit/edd73384c427d9afe63bae9d03baa2a26f7b7f54

    minimumServerProtocolVersion

    minimum supported TLS protocol. Set None (or null in config file) to default to JVM settings.

    ciphers

    supported ciphers. Set to None (or null in config file) to default to JVM settings.

    enableCertRevocationChecking

    whether to enable certificate revocation checking per https://tersesystems.com/blog/2014/03/22/fixing-certificate-revocation/ TODO(#4881): implement cert-revocation at the participant and domain admin endpoints Ledger api server reference PR: https://github.com/digital-asset/daml/pull/7965

99.  final case class VegasLimit(maxConcurrency: Option[Int], smoothing: Option[Double]) extends LimitConfig with Product with Serializable

    Uses an algorithm inspired by TCP-Vegas to estimate ideal limit.

    Uses an algorithm inspired by TCP-Vegas to estimate ideal limit.

    https://javadoc.io/static/com.netflix.concurrency-limits/concurrency-limits-core/0.3.6/com/netflix/concurrency/limits/limit/VegasLimit.html

100.  final case class WatchdogConfig(enabled: Boolean, checkInterval: PositiveFiniteDuration = PositiveFiniteDuration(15.seconds), killDelay: NonNegativeFiniteDuration = NonNegativeFiniteDuration(30.seconds)) extends Product with Serializable
101.  final case class WindowedLimit(windowSize: Option[Int] = None, delegate: LimitConfig) extends ConcurrencyLimitConfig with Product with Serializable

     Use a deligate concurrency limiter, supplying it data averaged over windows of at least windowSize

     Use a deligate concurrency limiter, supplying it data averaged over windows of at least windowSize

     Corresponds to https://javadoc.io/static/com.netflix.concurrency-limits/concurrency-limits-core/0.3.6/com/netflix/concurrency/limits/limit/WindowedLimit.html