cresettings

package
v1.3.1 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Jul 8, 2026 License: MIT Imports: 7 Imported by: 14

README

CRE Settings

---
title: Legend
---
flowchart
    bound{{Bound}}
    gate[/Gate\]
    queue[[Queue]]
    rate[\Rate/]
    resource([Resource])
    time>Time]
    setting[(Setting)]
    
    bound:::bound
    gate:::gate
    queue:::queue
    rate:::rate
    resource:::resource
    time:::time
    setting:::setting

    classDef bound stroke:#f00
    classDef gate stroke:#0f0
    classDef queue stroke:#00f
    classDef rate stroke:#ff0
    classDef resource stroke:#f0f
    classDef time stroke:#0ff
    classDef setting stroke:#999
---
title: Limits
---
flowchart
    subgraph handleRequest[httpServer/websocketServer.handleRequest]
        GatewayIncomingPayloadSizeLimit{{GatewayIncomingPayloadSizeLimit}}:::bound
%%        TODO GatewayVaultManagementEnabled
        VaultJWTAuthEnabled[/VaultJWTAuthEnabled\]:::gate
        VaultOrgIdAsSecretOwnerEnabled[/VaultOrgIdAsSecretOwnerEnabled\]:::gate
        TenantID[(TenantID)]:::setting
        PropagateOrgIDInRequestMetadata[/PropagateOrgIDInRequestMetadata\]:::gate
        VaultBase64EncodingEnabled[/VaultBase64EncodingEnabled\]:::gate
        VaultForceEmptyOCRRounds[/VaultForceEmptyOCRRounds\]:::gate
        VaultOptimizationsEnabled[/VaultOptimizationsEnabled\]:::gate
        VaultGetSecretsShareAggregationIncludesPublicKeys[/VaultGetSecretsShareAggregationIncludesPublicKeys\]:::gate
        VaultOwnerAddressCanonicalizationEnabled[/VaultOwnerAddressCanonicalizationEnabled\]:::gate
        VaultJSONOmitUnpopulatedEnabled[/VaultJSONOmitUnpopulatedEnabled\]:::gate
    end

    subgraph HandleNodeMessage[gatewayHandler.HandleNodeMessage]
%%      DON nodes → gateway (separate from the inbound trigger flow)
        GatewayHTTPGlobalRate[\GatewayHTTPGlobalRate/]:::rate
        GatewayHTTPPerNodeRate[\GatewayHTTPPerNodeRate/]:::rate
        GatewayConfidentialRelayGlobalRate[\GatewayConfidentialRelayGlobalRate/]:::rate
        GatewayConfidentialRelayPerNodeRate[\GatewayConfidentialRelayPerNodeRate/]:::rate
        GatewayHTTPActionMtlsRequestRate[\GatewayHTTPActionMtlsRequestRate/]:::rate
        GatewayHTTPActionMtlsConcurrencyLimit([GatewayHTTPActionMtlsConcurrencyLimit]):::resource
    end
%%    TODO unused
%%    PerOrg.ZeroBalancePruningTimeout

    subgraph Store.FetchWorkflowArtifacts
        CentralizedWorkflowOwnerVerificationEnabled[/CentralizedWorkflowOwnerVerificationEnabled\]:::gate
        PerWorkflow.WASMConfigSizeLimit{{PerWorkflow.WASMConfigSizeLimit}}:::bound
        PerWorkflow.WASMBinarySizeLimit{{PerWorkflow.WASMBinarySizeLimit}}:::bound
        PerWorkflow.WASMSecretsSizeLimit{{PerWorkflow.WASMSecretsSizeLimit}}:::bound
    end

    subgraph host.NewModule
        PerWorkflow.WASMCompressedBinarySizeLimit{{PerWorkflow.WASMCompressedBinarySizeLimit}}:::bound
    end
    
    subgraph Engine.init
%%        TODO move and replace with WorkflowLimit
        WorkflowLimit([WorkflowLimit]):::resource
        PerOwner.WorkflowLimit([PerOwner.WorkflowLimit]):::resource

        WorkflowLimit-->PerOwner.WorkflowLimit
    end
    
    subgraph Engine.runTriggerSubscriptionPhase
        TriggerRegistrationStatusUpdateTimeout([TriggerRegistrationStatusUpdateTimeout]):::time
        PerWorkflow.TriggerSubscriptionTimeout>PerWorkflow.TriggerSubscriptionTimeout]:::time
        PerWorkflow.WASMMemoryLimit{{PerWorkflow.WASMMemoryLimit}}:::bound
        PerWorkflow.TriggerRegistrationsTimeout>PerWorkflow.TriggerRegistrationsTimeout]:::time
        PerWorkflow.TriggerSubscriptionLimit{{PerWorkflow.TriggerSubscriptionLimit}}:::bound
        
        PerWorkflow.TriggerSubscriptionTimeout-->PerWorkflow.WASMMemoryLimit-->PerWorkflow.TriggerSubscriptionLimit-->PerWorkflow.TriggerRegistrationsTimeout
    end

    subgraph triggers
        direction TB

        subgraph PerWorkflow.CRONTrigger
            PerWorkflow.CRONTrigger.FastestScheduleInterval>FastestScheduleInterval]:::time
        end
        subgraph PerWorkflow.HTTPTrigger
            PerWorkflow.HTTPTrigger.RateLimit[\RateLimit/]:::rate
        end
        subgraph PerWorkflow.LogTrigger
            direction LR

            PerWorkflow.LogTrigger.EventRateLimit[\EventRateLimit/]:::rate
            PerWorkflow.LogTrigger.EventSizeLimit{{EventSizeLimit}}:::bound
            PerWorkflow.LogTrigger.FilterAddressLimit{{FilterAddressLimit}}:::bound
            PerWorkflow.LogTrigger.FilterTopicsPerSlotLimit{{FilterTopicsPerSlotLimit}}:::bound
        end
        subgraph EVMLogTriggerCapability[EVM log trigger capability startup]
            PerOrg.BaseTriggerRetransmitEnabled[/PerOrg.BaseTriggerRetransmitEnabled\]:::gate
            BaseTriggerRetryInterval>BaseTriggerRetryInterval]:::time
            BaseTriggerMaxRetries{{BaseTriggerMaxRetries}}:::bound
            BaseTriggerPruneAge>BaseTriggerPruneAge]:::time
            BaseTriggerMaxSendsPerTick{{BaseTriggerMaxSendsPerTick}}:::bound
        end
    end

    subgraph Engine.handleAllTriggerEvents
        PerWorkflow.TriggerEventQueueLimit[[PerWorkflow.TriggerEventQueueLimit]]:::queue
        PerWorkflow.TriggerEventQueueTimeout>PerWorkflow.TriggerEventQueueTimeout]:::time
        
        subgraph multiExecutionConcurrencyLimiter
            WorkflowExecutionConcurrencyLimit([WorkflowExecutionConcurrencyLimit]):::resource
            PerOrg.WorkflowExecutionConcurrencyLimit([PerOrg.WorkflowExecutionConcurrencyLimit]):::resource
            PerOwner.WorkflowExecutionConcurrencyLimit([PerOwner.WorkflowExecutionConcurrencyLimit]):::resource
            PerWorkflow.ExecutionConcurrencyLimit([PerWorkflow.ExecutionConcurrencyLimit]):::resource
            WorkflowExecutionConcurrencyLimit-->PerOrg.WorkflowExecutionConcurrencyLimit-->PerOwner.WorkflowExecutionConcurrencyLimit-->PerWorkflow.ExecutionConcurrencyLimit
        end

        PerWorkflow.TriggerEventQueueLimit-->PerWorkflow.TriggerEventQueueTimeout-->multiExecutionConcurrencyLimiter
    end

    subgraph Engine.startExecution
        direction TB
    
        subgraph logs
            PerWorkflow.LogLineLimit{{PerWorkflow.LogLineLimit}}:::bound
            PerWorkflow.LogEventLimit{{PerWorkflow.LogEventLimit}}:::bound
        end

        subgraph metrics
            direction TB
            PerWorkflow.UserMetricEnabled[/PerWorkflow.UserMetricEnabled\]:::gate
            PerWorkflow.UserMetricPayloadLimit{{PerWorkflow.UserMetricPayloadLimit}}:::bound
            PerWorkflow.UserMetricNameLengthLimit{{PerWorkflow.UserMetricNameLengthLimit}}:::bound
            PerWorkflow.UserMetricLabelsPerMetric{{PerWorkflow.UserMetricLabelsPerMetric}}:::bound
            PerWorkflow.UserMetricLabelValueLength{{PerWorkflow.UserMetricLabelValueLength}}:::bound

            PerWorkflow.UserMetricEnabled-->PerWorkflow.UserMetricPayloadLimit-->PerWorkflow.UserMetricNameLengthLimit-->PerWorkflow.UserMetricLabelsPerMetric-->PerWorkflow.UserMetricLabelValueLength
        end
        
        PerWorkflow.ExecutionTimeout>PerWorkflow.ExecutionTimeout]:::time
        PerWorkflow.ExecutionResponseLimit{{PerWorkflow.ExecutionResponseLimit}}:::bound
        PerWorkflow.ExecutionTimestampsEnabled[/PerWorkflow.ExecutionTimestampsEnabled\]:::gate
        PerWorkflow.FeatureMultiTriggerExecutionIDsActiveAt[/PerWorkflow.FeatureMultiTriggerExecutionIDsActiveAt\]:::gate
        PerWorkflow.FeatureMultiTriggerExecutionIDsActivePeriod[/PerWorkflow.FeatureMultiTriggerExecutionIDsActivePeriod\]:::gate
        PerWorkflow.FeatureUseSingleDONTimeProviderPerExecutionActivePeriod[/PerWorkflow.FeatureUseSingleDONTimeProviderPerExecutionActivePeriod\]:::gate
        PerWorkflow.FeatureChainCapabilityHashBasedOCRActivePeriod[/PerWorkflow.FeatureChainCapabilityHashBasedOCRActivePeriod\]:::gate
        PerWorkflow.FeatureEVMWriteReportL1FeeActivePeriod[/PerWorkflow.FeatureEVMWriteReportL1FeeActivePeriod\]:::gate
        PerWorkflow.FeatureAptosWriteReportBlockTimestampActivePeriod[/PerWorkflow.FeatureAptosWriteReportBlockTimestampActivePeriod\]:::gate

        PerWorkflow.ExecutionTimestampsEnabled-->PerWorkflow.FeatureMultiTriggerExecutionIDsActivePeriod-->PerWorkflow.ExecutionTimeout-->PerWorkflow.ExecutionResponseLimit
    end
        
    subgraph ExecutionHelper.GetSecrets
        PerWorkflow.SecretsConcurrencyLimit([PerWorkflow.SecretsConcurrencyLimit]):::resource
    end
    subgraph ExecutionHelper.CallCapability
        PerWorkflow.ChainAllowed[/PerWorkflow.ChainAllowed\]:::gate
        PerWorkflow.CapabilityConcurrencyLimit([PerWorkflow.CapabilityConcurrencyLimit]):::resource
        PerWorkflow.CapabilityCallTimeout>PerWorkflow.CapabilityCallTimeout]:::time
        
        PerWorkflow.ChainAllowed-->PerWorkflow.CapabilityConcurrencyLimit-->PerWorkflow.CapabilityCallTimeout
    end
    
    subgraph actions
        direction TB
        
        subgraph PerWorkflow.ChainWrite
            direction LR

            PerWorkflow.ChainWrite.TargetsLimit{{TargetsLimit}}:::bound
            PerWorkflow.ChainWrite.ReportSizeLimit{{ReportSizeLimit}}:::bound

            subgraph EVM
                direction LR
                PerWorkflow.ChainWrite.EVM.ReportSizeLimit{{ReportSizeLimit}}:::bound
                PerWorkflow.ChainWrite.EVM.GasLimit{{GasLimit}}:::bound
%%                PerWorkflow.ChainWrite.EVM.TransactionGasLimit - Deprecated
            end
            subgraph Solana
                direction LR
                PerWorkflow.ChainWrite.Solana.ReportSizeLimit{{ReportSizeLimit}}:::bound
                PerWorkflow.ChainWrite.Solana.GasLimit{{GasLimit}}:::bound
            end
            subgraph Aptos
                direction LR
                PerWorkflow.ChainWrite.Aptos.ReportSizeLimit{{ReportSizeLimit}}:::bound
                PerWorkflow.ChainWrite.Aptos.GasLimit{{GasLimit}}:::bound
            end
        end
        subgraph PerWorkflow.ChainRead
            direction LR
            PerWorkflow.ChainRead.CallLimit{{CallLimit}}:::bound
            PerWorkflow.ChainRead.LogQueryBlockLimit{{LogQueryBlockLimit}}:::bound
            PerWorkflow.ChainRead.PayloadSizeLimit{{PayloadSizeLimit}}:::bound
        end
        subgraph PerWorkflow.Consensus
            PerWorkflow.Consensus.ObservationSizeLimit{{ObservationSizeLimit}}:::bound
            PerWorkflow.Consensus.CallLimit{{CallLimit}}:::bound
        end
        subgraph PerWorkflow.HTTPAction
            direction LR

            PerWorkflow.HTTPAction.CallLimit{{CallLimit}}:::bound
            PerWorkflow.HTTPAction.CacheAgeLimit{{CacheAgeLimit}}:::bound
            PerWorkflow.HTTPAction.ConnectionTimeout{{ConnectionTimeout}}:::bound
            PerWorkflow.HTTPAction.RequestSizeLimit{{RequestSizeLimit}}:::bound
            PerWorkflow.HTTPAction.ResponseSizeLimit{{ResponseSizeLimit}}:::bound
            PerWorkflow.HTTPAction.GatewayProxyDonID{{GatewayProxyDonID}}
        end
        subgraph PerWorkflow.ConfidentialHTTP
            direction LR

            PerWorkflow.ConfidentialHTTP.CallLimit{{CallLimit}}:::bound
            PerWorkflow.ConfidentialHTTP.ConnectionTimeout{{ConnectionTimeout}}:::bound
            PerWorkflow.ConfidentialHTTP.RequestSizeLimit{{RequestSizeLimit}}:::bound
            PerWorkflow.ConfidentialHTTP.ResponseSizeLimit{{ResponseSizeLimit}}:::bound
        end
        subgraph PerWorkflow.ConfidentialWorkflows
            PerWorkflow.ConfidentialWorkflows.Enabled[/Enabled\]:::gate
        end
        subgraph PerWorkflow.Secrets
            PerWorkflow.Secrets.CallLimit{{CallLimit}}:::bound
        end
        subgraph PerWorkflow.DONTime
            PerWorkflow.DONTime.RequestTimeout{{RequestTimeout}}:::time
        end
        subgraph PerOrg.HTTPAction
            PerOrg.HTTPAction.MtlsRateLimit{{PerOrg.HTTPAction.MtlsRateLimit}}:::bound
        end
    end
    subgraph vault
        VaultCiphertextSizeLimit{{VaultCiphertextSizeLimit}}:::bound
        VaultShareSizeLimit{{VaultShareSizeLimit}}:::bound
        VaultIdentifierKeySizeLimit{{VaultIdentifierKeySizeLimit}}:::bound
        VaultIdentifierOwnerSizeLimit{{VaultIdentifierOwnerSizeLimit}}:::bound
        VaultIdentifierNamespaceSizeLimit{{VaultIdentifierNamespaceSizeLimit}}:::bound
        VaultPluginBatchSizeLimit{{VaultPluginBatchSizeLimit}}:::bound
        VaultRequestBatchSizeLimit{{VaultRequestBatchSizeLimit}}:::bound
        VaultPendingQueueWriteSizeLimit{{VaultPendingQueueWriteSizeLimit}}:::bound
        VaultMaxQuerySizeLimit{{VaultMaxQuerySizeLimit}}:::bound
        VaultMaxObservationSizeLimit{{VaultMaxObservationSizeLimit}}:::bound
        VaultMaxReportsPlusPrecursorSizeLimit{{VaultMaxReportsPlusPrecursorSizeLimit}}:::bound
        VaultMaxReportSizeLimit{{VaultMaxReportSizeLimit}}:::bound
        VaultMaxReportCount{{VaultMaxReportCount}}:::bound
        VaultMaxKeyValueModifiedKeysPlusValuesSizeLimit{{VaultMaxKeyValueModifiedKeysPlusValuesSizeLimit}}:::bound
        VaultMaxKeyValueModifiedKeys{{VaultMaxKeyValueModifiedKeys}}:::bound
        VaultMaxBlobPayloadSizeLimit{{VaultMaxBlobPayloadSizeLimit}}:::bound
        VaultMaxPerOracleUnexpiredBlobCumulativePayloadSizeLimit{{VaultMaxPerOracleUnexpiredBlobCumulativePayloadSizeLimit}}:::bound
        VaultMaxPerOracleUnexpiredBlobCount{{VaultMaxPerOracleUnexpiredBlobCount}}:::bound
        PerOwner.VaultCiphertextSizeLimit{{PerOwner.VaultCiphertextSizeLimit}}:::bound
        PerOwner.VaultSecretsLimit{{PerOwner.VaultSecretsLimit}}:::bound
    end

    subgraph ConfidentialCompute[Confidential Compute executor]
        ConfidentialCompute.GlobalRate[\ConfidentialCompute.GlobalRate/]:::rate
        PerOwner.ConfidentialCompute.Rate[\PerOwner.ConfidentialCompute.Rate/]:::rate
        ConfidentialCompute.MaxRetries{{ConfidentialCompute.MaxRetries}}:::bound
        ConfidentialCompute.RetryBackoff>ConfidentialCompute.RetryBackoff]:::time
        ConfidentialCompute.SecretsCacheEnabled[/ConfidentialCompute.SecretsCacheEnabled\]:::gate
        ConfidentialCompute.EnclaveRequestTimeout>ConfidentialCompute.EnclaveRequestTimeout]:::time
        ConfidentialCompute.PublicKeyRequestTimeout>ConfidentialCompute.PublicKeyRequestTimeout]:::time
        ConfidentialCompute.InsecureSkipTLSVerify[/ConfidentialCompute.InsecureSkipTLSVerify\]:::gate
        ConfidentialCompute.EnclaveRefreshInterval>ConfidentialCompute.EnclaveRefreshInterval]:::time
        subgraph ConfidentialCompute.PublicKeyCache
            ConfidentialCompute.PublicKeyCache.Enabled[/Enabled\]:::gate
            ConfidentialCompute.PublicKeyCache.TTL>TTL]:::time
            ConfidentialCompute.PublicKeyCache.MaxTTL>MaxTTL]:::time
            ConfidentialCompute.PublicKeyCache.CleanupInterval>CleanupInterval]:::time
            ConfidentialCompute.PublicKeyCache.TTLBufferPercent{{TTLBufferPercent}}:::bound
            ConfidentialCompute.PublicKeyCache.ProactiveRefreshEnabled[/ProactiveRefreshEnabled\]:::gate
            ConfidentialCompute.PublicKeyCache.RefreshIntervalPercent{{RefreshIntervalPercent}}:::bound
            ConfidentialCompute.PublicKeyCache.MinRefreshInterval>MinRefreshInterval]:::time
            ConfidentialCompute.PublicKeyCache.RefreshTimeout>RefreshTimeout]:::time
        end
        subgraph ConfidentialCompute.Session
            ConfidentialCompute.Session.PersistenceEnabled[/PersistenceEnabled\]:::gate
            ConfidentialCompute.Session.HeaderName{{HeaderName}}:::bound
        end
    end

    handleRequest-->Store.FetchWorkflowArtifacts-->host.NewModule-->Engine.init-->Engine.runTriggerSubscriptionPhase-->triggers-->Engine.handleAllTriggerEvents-->Engine.startExecution
    Engine.startExecution-->ExecutionHelper.CallCapability-->actions
    Engine.startExecution-->PerWorkflow.SecretsConcurrencyLimit-->vault

%%  DON nodes → gateway is a separate entry point, not connected to the trigger/execution chain above
    HandleNodeMessage

    classDef bound stroke:#f00
    classDef gate stroke:#0f0
    classDef queue stroke:#00f
    classDef rate stroke:#ff0
    classDef resource stroke:#f0f
    classDef time stroke:#0ff
    classDef setting stroke:#999,fill:#f5f5f5

Documentation

Overview

Package cresettings contains configurable settings definitions for nodes in the CRE. Environment Variables:

  • CL_CRE_SETTINGS_DEFAULT: defaults like in ./defaults.json - initializes Default
  • CL_CRE_SETTINGS: scoped settings like in ../settings/testdata/config.json - initializes DefaultGetter

Index

Constants

View Source
const (
	EnvNameSettings        = "CL_CRE_SETTINGS"
	EnvNameSettingsDefault = "CL_CRE_SETTINGS_DEFAULT"
)

Variables

View Source
var Default = Schema{
	WorkflowLimit:                               Int(1000),
	WorkflowExecutionConcurrencyLimit:           Int(1000),
	GatewayIncomingPayloadSizeLimit:             Size(1 * config.MByte),
	GatewayVaultManagementEnabled:               Bool(true),
	VaultJWTAuthEnabled:                         Bool(false),
	CentralizedWorkflowOwnerVerificationEnabled: Bool(false),
	TenantID: Uint64(0),

	VaultOrgIdAsSecretOwnerEnabled:                    Bool(false),
	PropagateOrgIDInRequestMetadata:                   Bool(false),
	VaultBase64EncodingEnabled:                        Bool(false),
	VaultForceEmptyOCRRounds:                          Bool(false),
	VaultOptimizationsEnabled:                         Bool(false),
	VaultGetSecretsShareAggregationIncludesPublicKeys: Bool(false),
	VaultOwnerAddressCanonicalizationEnabled:          Bool(false),
	VaultJSONOmitUnpopulatedEnabled:                   Bool(false),
	GatewayHTTPGlobalRate:                             Rate(rate.Limit(500), 500),
	GatewayHTTPPerNodeRate:                            Rate(rate.Limit(100), 100),
	GatewayConfidentialRelayGlobalRate:                Rate(rate.Limit(50), 10),
	GatewayConfidentialRelayPerNodeRate:               Rate(rate.Limit(10), 10),
	GatewayHTTPActionMtlsRequestRate:                  Rate(rate.Every(30*time.Second), 0),
	GatewayHTTPActionMtlsConcurrencyLimit:             Int(50),
	TriggerRegistrationStatusUpdateTimeout:            Duration(0 * time.Second),
	BaseTriggerRetryInterval:                          Duration(30 * time.Second),
	BaseTriggerMaxRetries:                             Int(20),
	BaseTriggerPruneAge:                               Duration(24 * time.Hour),
	BaseTriggerMaxSendsPerTick:                        Int(20),

	VaultCiphertextSizeLimit:          Size(2 * config.KByte),
	VaultIdentifierKeySizeLimit:       Size(64 * config.Byte),
	VaultIdentifierOwnerSizeLimit:     Size(64 * config.Byte),
	VaultIdentifierNamespaceSizeLimit: Size(64 * config.Byte),
	VaultPluginBatchSizeLimit:         Int(10),
	VaultRequestBatchSizeLimit:        Int(10),
	VaultPendingQueueWriteSizeLimit:   Int(1000),
	VaultShareSizeLimit:               Size(600 * config.Byte),

	VaultMaxQuerySizeLimit:       Size(102400 * config.Byte),
	VaultMaxObservationSizeLimit: Size(512 * config.KByte),

	VaultMaxReportsPlusPrecursorSizeLimit: Size(2 * config.MByte),
	VaultMaxReportSizeLimit:               Size(2 * config.MByte),
	VaultMaxReportCount:                   Int(10),

	VaultMaxKeyValueModifiedKeysPlusValuesSizeLimit: Size(1468006 * config.Byte),

	VaultMaxKeyValueModifiedKeys: Int(300),

	VaultMaxBlobPayloadSizeLimit: Size(25600 * config.Byte),

	VaultMaxPerOracleUnexpiredBlobCumulativePayloadSizeLimit: Size(31457280 * config.Byte),
	VaultMaxPerOracleUnexpiredBlobCount:                      Int(1000),

	ConfidentialCompute: confidentialCompute{
		GlobalRate:              Rate(rate.Limit(1000), 1000),
		MaxRetries:              Int(3),
		RetryBackoff:            Duration(2 * time.Second),
		SecretsCacheEnabled:     Bool(false),
		EnclaveRequestTimeout:   Duration(30 * time.Second),
		PublicKeyRequestTimeout: Duration(5 * time.Second),
		InsecureSkipTLSVerify:   Bool(false),
		EnclaveRefreshInterval:  Duration(10 * time.Second),
		PublicKeyCache: ccPublicKeyCache{
			Enabled:                 Bool(true),
			TTL:                     Duration(5 * time.Minute),
			MaxTTL:                  Duration(30 * time.Minute),
			CleanupInterval:         Duration(10 * time.Minute),
			TTLBufferPercent:        Float64(0.1),
			ProactiveRefreshEnabled: Bool(true),
			RefreshIntervalPercent:  Float64(0),
			MinRefreshInterval:      Duration(10 * time.Second),
			RefreshTimeout:          Duration(5 * time.Second),
		},
		Session: ccSession{
			PersistenceEnabled: Bool(true),
			HeaderName:         String("Sticky-Session-A"),
		},
	},

	PerOrg: Orgs{
		BaseTriggerRetransmitEnabled:      Bool(false),
		WorkflowExecutionConcurrencyLimit: Int(100),
		ZeroBalancePruningTimeout:         Duration(24 * time.Hour),
		HTTPAction: perOrgHTTPAction{
			MtlsRateLimit: Rate(rate.Every(30*time.Second), 3),
		},
	},
	PerOwner: Owners{
		WorkflowLimit:                     Int(1000),
		WorkflowExecutionConcurrencyLimit: Int(5),

		VaultCiphertextSizeLimit: Size(2 * config.KByte),
		VaultSecretsLimit:        Int(100),

		ConfidentialCompute: ownerConfidentialCompute{
			Rate: Rate(rate.Limit(1000), 1000),
		},
	},
	PerWorkflow: Workflows{
		TriggerRegistrationsTimeout:   Duration(10 * time.Second),
		TriggerEventQueueLimit:        Int(50),
		TriggerEventQueueTimeout:      Duration(10 * time.Minute),
		TriggerSubscriptionTimeout:    Duration(15 * time.Second),
		TriggerSubscriptionLimit:      Int(10),
		CapabilityConcurrencyLimit:    Int(30),
		CapabilityCallTimeout:         Duration(3 * time.Minute),
		SecretsConcurrencyLimit:       Int(5),
		ExecutionConcurrencyLimit:     Int(5),
		ExecutionTimeout:              Duration(5 * time.Minute),
		ExecutionResponseLimit:        Size(100 * config.KByte),
		ExecutionTimestampsEnabled:    Bool(false),
		WASMMemoryLimit:               Size(100 * config.MByte),
		WASMBinarySizeLimit:           Size(100 * config.MByte),
		WASMCompressedBinarySizeLimit: Size(20 * config.MByte),
		WASMConfigSizeLimit:           Size(50 * config.KByte),
		WASMSecretsSizeLimit:          Size(27 * config.KByte),
		LogLineLimit:                  Size(config.KByte),
		LogEventLimit:                 Int(1_000),
		UserMetricEnabled:             Bool(false),
		UserMetricPayloadLimit:        Size(4 * config.KByte),
		UserMetricNameLengthLimit:     Int(128),
		UserMetricLabelsPerMetric:     Int(10),
		UserMetricLabelValueLength:    Int(256),
		ChainAllowed: PerChainSelector(Bool(false), map[string]bool{

			"12922642891491394802": true,

			"3379446385462418246": true,

			"12463857294658392847": true,
		}),

		CRONTrigger: cronTrigger{
			FastestScheduleInterval: Duration(30 * time.Second),
		},
		HTTPTrigger: httpTrigger{
			RateLimit: Rate(rate.Every(30*time.Second), 3),
		},
		LogTrigger: logTrigger{
			EventRateLimit:           Rate(rate.Every(time.Minute/10), 10),
			FilterAddressLimit:       Int(5),
			FilterTopicsPerSlotLimit: Int(10),
			EventSizeLimit:           Size(5 * config.KByte),
		},

		ChainWrite: chainWrite{
			TargetsLimit:    Int(10),
			ReportSizeLimit: Size(5 * config.KByte),
			EVM: evmChainWrite{
				TransactionGasLimit: Uint64(5_000_000),
				GasLimit: PerChainSelector(Uint64(5_000_000), map[string]uint64{

					"3379446385462418246": 10_000_000,

					"12922642891491394802": 50_000_000,
				}),
				ReportSizeLimit: Size(5 * config.KByte),
			},
			Solana: solanaChainWrite{
				ReportSizeLimit: Size(265 * config.Byte),
				GasLimit:        PerChainSelector(Uint32(300_000), map[string]uint32{}),
			},
			Aptos: aptosChainWrite{
				ReportSizeLimit: Size(5 * config.KByte),
				GasLimit:        PerChainSelector(Uint64(2_000_000), map[string]uint64{}),
			},
		},
		ChainRead: chainRead{
			CallLimit:          Int(15),
			LogQueryBlockLimit: Uint64(100),
			PayloadSizeLimit:   Size(5 * config.KByte),
		},
		Consensus: consensus{
			ObservationSizeLimit: Size(100 * config.KByte),
			CallLimit:            Int(20),
		},
		HTTPAction: httpAction{
			CallLimit:         Int(5),
			CacheAgeLimit:     Duration(10 * time.Minute),
			ConnectionTimeout: Duration(10 * time.Second),
			RequestSizeLimit:  Size(10 * config.KByte),
			ResponseSizeLimit: Size(100 * config.KByte),
			GatewayProxyDonID: String(""),
		},
		ConfidentialHTTP: confidentialHTTP{
			CallLimit:         Int(5),
			ConnectionTimeout: Duration(10 * time.Second),
			RequestSizeLimit:  Size(10 * config.KByte),
			ResponseSizeLimit: Size(100 * config.KByte),
		},
		ConfidentialWorkflows: confidentialWorkflows{
			Enabled: Bool(false),
		},
		Secrets: secrets{
			CallLimit: Int(5),
		},
		DONTime: donTime{
			RequestTimeout: Duration(30 * time.Second),
		},

		FeatureMultiTriggerExecutionIDsActiveAt: Time(time.Date(2100, 1, 1, 0, 0, 0, 0, time.UTC)),
		FeatureMultiTriggerExecutionIDsActivePeriod: TimeRange(
			time.Date(2100, 1, 1, 0, 0, 0, 0, time.UTC),
			time.Date(2101, 1, 1, 0, 0, 0, 0, time.UTC)),
		FeatureUseSingleDONTimeProviderPerExecutionActivePeriod: TimeRange(
			time.Date(2100, 1, 1, 0, 0, 0, 0, time.UTC),
			time.Date(2101, 1, 1, 0, 0, 0, 0, time.UTC)),
		FeatureChainCapabilityHashBasedOCRActivePeriod: TimeRange(
			time.Date(2100, 1, 1, 0, 0, 0, 0, time.UTC),
			time.Date(2101, 1, 1, 0, 0, 0, 0, time.UTC)),
		FeatureEVMWriteReportL1FeeActivePeriod: TimeRange(
			time.Date(2100, 1, 1, 0, 0, 0, 0, time.UTC),
			time.Date(2101, 1, 1, 0, 0, 0, 0, time.UTC)),
		FeatureAptosWriteReportBlockTimestampActivePeriod: TimeRange(
			time.Date(2100, 1, 1, 0, 0, 0, 0, time.UTC),
			time.Date(2101, 1, 1, 0, 0, 0, 0, time.UTC)),
	},
}
View Source
var DefaultGetter Getter

DefaultGetter is a default settings getter populated from the env var CL_CRE_SETTINGS if set, otherwise it is nil.

Functions

This section is empty.

Types

type Orgs added in v0.9.1

type Orgs struct {
	BaseTriggerRetransmitEnabled      Setting[bool]
	WorkflowExecutionConcurrencyLimit Setting[int] `unit:"{workflow}"`
	ZeroBalancePruningTimeout         Setting[time.Duration]
	HTTPAction                        perOrgHTTPAction
}

type Owners added in v0.9.1

type Owners struct {
	WorkflowLimit                     Setting[int] `unit:"{workflow}"`
	WorkflowExecutionConcurrencyLimit Setting[int] `unit:"{workflow}"`
	VaultCiphertextSizeLimit          Setting[config.Size]
	VaultSecretsLimit                 Setting[int] `unit:"{secret}"`

	// ConfidentialCompute holds the per-workflow-owner Confidential Compute settings.
	ConfidentialCompute ownerConfidentialCompute
}

type Schema added in v0.9.1

type Schema struct {
	WorkflowLimit                                     Setting[int] `unit:"{workflow}"`
	WorkflowExecutionConcurrencyLimit                 Setting[int] `unit:"{workflow}"`
	GatewayIncomingPayloadSizeLimit                   Setting[config.Size]
	GatewayVaultManagementEnabled                     Setting[bool]
	VaultJWTAuthEnabled                               Setting[bool]
	CentralizedWorkflowOwnerVerificationEnabled       Setting[bool]
	TenantID                                          Setting[uint64]
	VaultOrgIdAsSecretOwnerEnabled                    Setting[bool] // Deprecated
	PropagateOrgIDInRequestMetadata                   Setting[bool]
	VaultBase64EncodingEnabled                        Setting[bool]
	VaultForceEmptyOCRRounds                          Setting[bool]
	VaultOptimizationsEnabled                         Setting[bool]
	VaultGetSecretsShareAggregationIncludesPublicKeys Setting[bool]
	VaultOwnerAddressCanonicalizationEnabled          Setting[bool]
	VaultJSONOmitUnpopulatedEnabled                   Setting[bool]
	GatewayHTTPGlobalRate                             Setting[config.Rate]
	GatewayHTTPPerNodeRate                            Setting[config.Rate]
	GatewayConfidentialRelayGlobalRate                Setting[config.Rate]
	GatewayConfidentialRelayPerNodeRate               Setting[config.Rate]
	GatewayHTTPActionMtlsRequestRate                  Setting[config.Rate]
	GatewayHTTPActionMtlsConcurrencyLimit             Setting[int] `unit:"{request}"`
	TriggerRegistrationStatusUpdateTimeout            Setting[time.Duration]

	BaseTriggerRetryInterval   Setting[time.Duration]
	BaseTriggerMaxRetries      Setting[int] `unit:"{attempt}"`
	BaseTriggerPruneAge        Setting[time.Duration]
	BaseTriggerMaxSendsPerTick Setting[int] `unit:"{event}"`

	// Deprecated: Use global.PerOwner.VaultCiphertextSizeLimit (global) or owner.<addr>.PerOwner.VaultCiphertextSizeLimit (per owner) instead.
	VaultCiphertextSizeLimit          Setting[config.Size]
	VaultShareSizeLimit               Setting[config.Size]
	VaultIdentifierKeySizeLimit       Setting[config.Size]
	VaultIdentifierOwnerSizeLimit     Setting[config.Size]
	VaultIdentifierNamespaceSizeLimit Setting[config.Size]
	VaultPluginBatchSizeLimit         Setting[int] `unit:"{request}"`
	VaultRequestBatchSizeLimit        Setting[int] `unit:"{request}"`
	VaultPendingQueueWriteSizeLimit   Setting[int] `unit:"{request}"`

	VaultMaxQuerySizeLimit                                   Setting[config.Size]
	VaultMaxObservationSizeLimit                             Setting[config.Size]
	VaultMaxReportsPlusPrecursorSizeLimit                    Setting[config.Size]
	VaultMaxReportSizeLimit                                  Setting[config.Size]
	VaultMaxReportCount                                      Setting[int]
	VaultMaxKeyValueModifiedKeysPlusValuesSizeLimit          Setting[config.Size]
	VaultMaxKeyValueModifiedKeys                             Setting[int]
	VaultMaxBlobPayloadSizeLimit                             Setting[config.Size]
	VaultMaxPerOracleUnexpiredBlobCumulativePayloadSizeLimit Setting[config.Size]
	VaultMaxPerOracleUnexpiredBlobCount                      Setting[int]

	// Confidential Compute (San Marino framework) node-level settings.
	ConfidentialCompute confidentialCompute

	PerOrg      Orgs      `scope:"org"`
	PerOwner    Owners    `scope:"owner"`
	PerWorkflow Workflows `scope:"workflow"`
}
var Config Schema

Deprecated: use Default

type Workflows added in v0.9.1

type Workflows struct {
	TriggerRegistrationsTimeout Setting[time.Duration]
	TriggerSubscriptionTimeout  Setting[time.Duration]
	TriggerSubscriptionLimit    Setting[int] `unit:"{subscription}"`
	TriggerEventQueueLimit      Setting[int] `unit:"{trigger}"`
	TriggerEventQueueTimeout    Setting[time.Duration]

	CapabilityConcurrencyLimit Setting[int] `unit:"{capability}"`
	CapabilityCallTimeout      Setting[time.Duration]

	SecretsConcurrencyLimit Setting[int] `unit:"{secret}"`

	ExecutionConcurrencyLimit  Setting[int] `unit:"{workflow}"`
	ExecutionTimeout           Setting[time.Duration]
	ExecutionResponseLimit     Setting[config.Size]
	ExecutionTimestampsEnabled Setting[bool]

	WASMMemoryLimit               Setting[config.Size]
	WASMBinarySizeLimit           Setting[config.Size]
	WASMCompressedBinarySizeLimit Setting[config.Size]
	WASMConfigSizeLimit           Setting[config.Size]
	WASMSecretsSizeLimit          Setting[config.Size]

	LogLineLimit  Setting[config.Size]
	LogEventLimit Setting[int] `unit:"{log}"`

	UserMetricEnabled          Setting[bool]
	UserMetricPayloadLimit     Setting[config.Size]
	UserMetricNameLengthLimit  Setting[int] `unit:"{char}"`
	UserMetricLabelsPerMetric  Setting[int] `unit:"{label}"`
	UserMetricLabelValueLength Setting[int] `unit:"{char}"`

	ChainAllowed SettingMap[bool]

	CRONTrigger cronTrigger
	HTTPTrigger httpTrigger
	LogTrigger  logTrigger

	ChainWrite            chainWrite
	ChainRead             chainRead
	Consensus             consensus
	HTTPAction            httpAction
	ConfidentialHTTP      confidentialHTTP
	ConfidentialWorkflows confidentialWorkflows
	Secrets               secrets
	DONTime               donTime

	FeatureMultiTriggerExecutionIDsActiveAt                 Setting[config.Timestamp] // Deprecated
	FeatureMultiTriggerExecutionIDsActivePeriod             Setting[Range[config.Timestamp]]
	FeatureUseSingleDONTimeProviderPerExecutionActivePeriod Setting[Range[config.Timestamp]]
	FeatureChainCapabilityHashBasedOCRActivePeriod          Setting[Range[config.Timestamp]]
	FeatureEVMWriteReportL1FeeActivePeriod                  Setting[Range[config.Timestamp]]
	FeatureAptosWriteReportBlockTimestampActivePeriod       Setting[Range[config.Timestamp]]
}

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL