# GeneralSettings section of the node
[GeneralSettings]
    # StatusPollingIntervalSec represents the no of seconds between multiple polling for the status for AppStatusHandler
    StatusPollingIntervalSec = 2

    # MaxComputableRounds represents the max number of rounds computable in a round
    # by the validator statistics processor
    MaxComputableRounds = 100

    # StartInEpochEnabled represents that the fast bootstrap mechanism from the network is enabled if data is not
    # available in local disk
    StartInEpochEnabled = true

    # ChainID represents the chain identifier
    # The currently supported constants are:
    #   "1" for Mainnet
    #   "D" for Devnet
    #   "T" for Testnet
    ChainID = "1"

    # MinTransactionVersion represents the minimum transaction version accepted
    MinTransactionVersion = 1

    # GenesisString represents the encoded string for the genesis block
    GenesisString = "546f207369676e69666963616e746c7920616363656c657261746520616c6c20746563686e6f6c6f676965732c20616e64207261646963616c6c7920696d70726f766520736f63696574792c2068756d616e6974792077696c6c206861766520746f206d69677261746520746f206120706f737420736361726369747920776f726c642e20456c726f6e642069732074686520666972737420636f6d706c65746520736f6c7574696f6e20746861742077696c6c20617474656d707420616e64206163686965766520746869732e0a0a54686520666f756e64696e67207465616d206f6620456c726f6e642069733a0a42656e69616d696e204d696e63750a4c756369616e204d696e63750a4c756369616e20546f6465610a41647269616e20446f62726974610a526f6265727420536173750a5261647520436869730a49756c69616e2050617363616c61750a53656261737469616e204d617269616e0a416e64726569204d6172696e6963610a437269737469616e20436f72636f7665616e750a44616e20566f6963750a44616e69656c20536572620a0a4e6f7461626c6520636f6e7472696275746f72733a0a42656e69616d696e20447261736f7665616e0a46656c69782043726973616e0a436f6e7374616e74696e20546f766973690a43616d696c2042616e63696f69750a416e647265692042616e63696f69750a416e64726569204164616d0a5365766572204d6f6c646f7665616e"

    # GenesisMaxNumberOfShards represents the maximum number of shards to be created at genesis (excluding metaChain shard)
    GenesisMaxNumberOfShards  = 3

    # SyncProcessTimeInMillis is the value in milliseconds used when processing blocks while synchronizing blocks
    SyncProcessTimeInMillis = 12000

    # SyncProcessTimeSupernovaInMillis is the value in milliseconds used when processing blocks while synchronizing blocks after Supernova
    SyncProcessTimeSupernovaInMillis = 12000

    # SetGuardianEpochsDelay represents the delay in epochs between the execution time of the SetGuardian transaction and
    # the activation of the configured guardian.
    # Make sure that this is greater than the unbonding period!
    SetGuardianEpochsDelay = 20 # 2 times the normal unstaking period

    # MaxProposalNonceGap defines the maximum gap allowed between the highest finalized nonce and lowest proposed nonce
    MaxProposalNonceGap = 20

# ChainParametersByEpoch defines chain operation configurable values that can be modified based on epochs
ChainParametersByEpoch = [
    { EnableEpoch = 0, RoundDuration = 6000, RoundsPerEpoch = 14400, MinRoundsBetweenEpochs = 14400, ShardConsensusGroupSize = 63, ShardMinNumNodes = 400, MetachainConsensusGroupSize = 400, MetachainMinNumNodes = 400, Hysteresis = 0.2, Adaptivity = false, Offset = 0 },
    { EnableEpoch = 1763, RoundDuration = 6000, RoundsPerEpoch = 14400, MinRoundsBetweenEpochs = 14400, ShardConsensusGroupSize = 400, ShardMinNumNodes = 400, MetachainConsensusGroupSize = 400, MetachainMinNumNodes = 400, Hysteresis = 0.2, Adaptivity = false, Offset = 0 },
    { EnableEpoch = 2233, RoundDuration = 600, RoundsPerEpoch = 144000, MinRoundsBetweenEpochs = 144000, ShardConsensusGroupSize = 400, ShardMinNumNodes = 400, MetachainConsensusGroupSize = 400, MetachainMinNumNodes = 400, Hysteresis = 0.2, Adaptivity = false, Offset = 2 }
]

# EpochChangeGracePeriodEnableEpoch represents the configuration of different grace periods for epoch change with their activation epochs
EpochChangeGracePeriodByEpoch = [
    {EnableEpoch = 0, GracePeriodInRounds = 5 },
    {EnableEpoch = 1763, GracePeriodInRounds = 10 }, # Andromeda epoch comes with a longer grace period
    {EnableEpoch = 2233, GracePeriodInRounds = 100 }, # Supernova epoch comes with an even longer grace period due to round duration reduction
]

# ProcessConfigsByEpoch represents the configuration of process configuration parameters by epoch
ProcessConfigsByEpoch = [
    { EnableEpoch = 0, MaxMetaNoncesBehind = 15, MaxMetaNoncesBehindForGlobalStuck = 30, MaxShardNoncesBehind = 15 },
    # Pre-Supernova epoch (immediately before Supernova) configuration
    { EnableEpoch = 2232, MaxMetaNoncesBehind = 5, MaxMetaNoncesBehindForGlobalStuck = 8, MaxShardNoncesBehind = 5 },
    { EnableEpoch = 2233, MaxMetaNoncesBehind = 5, MaxMetaNoncesBehindForGlobalStuck = 8, MaxShardNoncesBehind = 5 },
]

ConsensusConfigsByRound = [
    {
    EnableRound = 0,
    SubroundsTiming = [
        { StartTime = 0.0,  EndTime = 0.05 },  # start round
        { StartTime = 0.05, EndTime = 0.25 },  # block
        { StartTime = 0.25, EndTime = 0.85 },  # signature
        { StartTime = 0.85, EndTime = 0.95 },  # end round
    ],
    ProcessingThresholdPercent = 85
    },
    {
    EnableRound = 32157661,
    SubroundsTiming = [
        { StartTime = 0.0,  EndTime = 0.05 },  # start round
        { StartTime = 0.05, EndTime = 0.35 },  # block
        { StartTime = 0.35, EndTime = 0.65 },  # signature
        { StartTime = 0.65, EndTime = 0.95 },  # end round
    ],
    ProcessingThresholdPercent = 85
    }
]

ProcessConfigsByRound = [
    {
    EnableRound = 0,
    MaxRoundsWithoutNewBlockReceived = 10,
    MaxRoundsWithoutCommittedBlock = 10,
    RoundModulusTriggerWhenSyncIsStuck = 20,
    MaxSyncWithErrorsAllowed = 10,
    MaxRoundsToKeepUnprocessedMiniBlocks = 300,
    MaxRoundsToKeepUnprocessedTransactions = 300,
    # MaxConsecutiveRoundsOfRatingDecrease represents the max number of consecutive rounds in which a block is not proposed
    # on a shard and the validators' rating could be decreased. If, for instance, a shard gets stuck for more rounds
    # than this value, then the validators rating decrease should stop so they won't get jailed
    MaxConsecutiveRoundsOfRatingDecrease = 600,
    # MaxRoundsOfInactivityAccepted defines the number of rounds missed by a main or higher level backup machine before
    # the current machine will take over and propose/sign blocks. Used in both single-key and multi-key modes.
    MaxRoundsOfInactivityAccepted = 3,
    MaxBlockProcessingTimeMs = 6000, # this is only used after Supernova
    NumHeadersToRequestInAdvance = 10,
    ExtraDelayForBroadcastBlockInfoMs = 1000,
    ExtraDelayBetweenBroadcastMbsAndTxsMs = 1000,
    ExtraDelayForRequestBlockInfoMs = 3000
    },
    {
    EnableRound = 32157661,
    MaxRoundsWithoutNewBlockReceived = 100,
    MaxRoundsWithoutCommittedBlock = 100,
    RoundModulusTriggerWhenSyncIsStuck = 20,
    MaxSyncWithErrorsAllowed = 100,
    MaxRoundsToKeepUnprocessedMiniBlocks = 3000,
    MaxRoundsToKeepUnprocessedTransactions = 3000,
    MaxConsecutiveRoundsOfRatingDecrease = 6000,
    MaxRoundsOfInactivityAccepted = 30,
    MaxBlockProcessingTimeMs = 6000,
    NumHeadersToRequestInAdvance = 10,
    ExtraDelayForBroadcastBlockInfoMs = 30,
    ExtraDelayBetweenBroadcastMbsAndTxsMs = 50,
    ExtraDelayForRequestBlockInfoMs = 400
    }
]

EpochStartConfigsByEpoch = [
    { EnableEpoch = 0, GracePeriodRounds = 25 },
    { EnableEpoch = 2233, GracePeriodRounds = 250 },
]

EpochStartConfigsByRound = [
    { EnableRound = 0, MaxRoundsWithoutCommittedStartInEpochBlock = 50 },
    { EnableRound = 32157661, MaxRoundsWithoutCommittedStartInEpochBlock = 500 },
]

ConsensusConfigsByEpoch = [
    { EnableEpoch = 0, NumRoundsToWaitBeforeSignalingChronologyStuck = 10 },
    { EnableEpoch = 2233, NumRoundsToWaitBeforeSignalingChronologyStuck = 100 },
]

[HardwareRequirements]
    CPUFlags = []

[Versions]
    DefaultVersion = "default"
    VersionsByEpochs = [
        { StartEpoch = 0, StartRound = 0, Version = "*" },
        # The value of StartEpoch parameter for version 2 should be the same with the ScheduledMiniBlocksEnableEpoch flag from enableEpoch.toml file
        { StartEpoch = 613, StartRound = 0, Version = "2" },
        # TODO The value of StartEpoch parameter for version 3 should be the same with the SupernovaEnableEpoch flag from enableEpoch.toml file and StartRound the same with the SupernovaEnableRound flag from enableRounds.toml
        { StartEpoch = 2233, StartRound = 32157661, Version = "3" },
    ]

[StoragePruning]
    # If the Enabled flag is set to false, then the storers won't divide epochs into separate dbs
    Enabled = true

    # If this flag is set to false, the node won't delete any database between epochs
    # Applicable only for validators
    ValidatorCleanOldEpochsData = true

    # If this flag is set to false, the node won't delete any database between epochs
    # Applicable only for observers
    ObserverCleanOldEpochsData = false

    # If this flag is set to false, the node won't delete the AccountsTrie database for old epochs
    # Applicable for both observers and validators
    # WARNING! Setting this to false will increase each epoch's directory size with the trie snapshot,
    # which might easily cause the node to run out of disk space.
    AccountsTrieCleanOldEpochsData = true

    # AccountsTrieSkipRemovalCustomPattern represents the custom pattern that determines when AccountsTrie database
    # doesn't have to be cleaned
    # Format: %x,%y - if an epoch is divisible by x or by y, then the AccountsTrie database won't be removed
    # If empty, then all databases will be removed
    # If invalid format, then an error will be returned
    # Applicable only if AccountsTrieCleanOldEpochsData is set to true
    AccountsTrieSkipRemovalCustomPattern = "%50"

    # NumEpochsToKeep - if the flag above is set to true, this will set the number of epochs to keep in the storage.
    # Epochs older that (current epoch - NumOfEpochsToKeep) will be removed
    NumEpochsToKeep = 4

    # NumActivePersisters - this will set the number of persisters to keep active at a moment. This works even if
    # the node removes old epochs data or not. In case of a node which removes old epochs data, this value has to be
    # smaller or equal to the NumOfEpochsToKeep flag
    NumActivePersisters = 3

    # AssumedPeersNumActivePersisters represents the NumActivePersisters value the other (pruning) nodes in the
    # network are assumed to run with. Used only to decide up to which epoch data can still be requested from
    # regular peers. Keep in sync with the NumActivePersisters default shipped to validators/observers.
    # A missing or 0 value falls back to the default of 3, with a warning at startup
    AssumedPeersNumActivePersisters = 3

    # FullArchiveNumActivePersisters represents the number of persisters to be kept in cache as to allow better response
    # to inquiring peers. This value will get multiplied by the number of persisters required by the node to function so
    # it is a good idea to increase the maximum number of opened files allowed by the operating system
    FullArchiveNumActivePersisters = 10

[MiniBlocksStorage]
    [MiniBlocksStorage.Cache]
        Name = "MiniBlocksStorage"
        Capacity = 1000
        Type = "SizeLRU"
        SizeInBytes = 104857600 #100MB
    [MiniBlocksStorage.DB]
        FilePath = "MiniBlocks"
        Type = "LvlDBSerial"
        BatchDelaySeconds = 2
        MaxBatchSize = 100
        MaxOpenFiles = 10
        BloomFilterBitsPerKey = 10

[ReceiptsStorage]
    [ReceiptsStorage.Cache]
        Name = "ReceiptsStorage"
        Capacity = 1000
        Type = "SizeLRU"
        SizeInBytes = 10485760 #10MB
    [ReceiptsStorage.DB]
        FilePath = "Receipts"
        Type = "LvlDBSerial"
        BatchDelaySeconds = 2
        MaxBatchSize = 100
        MaxOpenFiles = 10
        BloomFilterBitsPerKey = 10

[ScheduledSCRsStorage]
    [ScheduledSCRsStorage.Cache]
        Name = "ScheduledSCRsStorage"
        Capacity = 1000
        Type = "SizeLRU"
        SizeInBytes = 10485760 #10MB
    [ScheduledSCRsStorage.DB]
        FilePath = "ScheduledSCRs"
        Type = "LvlDBSerial"
        BatchDelaySeconds = 2
        MaxBatchSize = 100
        MaxOpenFiles = 10
        BloomFilterBitsPerKey = 10

[PeerBlockBodyStorage]
    [PeerBlockBodyStorage.Cache]
        Name = "PeerBlockBodyStorage"
        Capacity = 1000
        Type = "SizeLRU"
        SizeInBytes = 104857600 #100MB
    [PeerBlockBodyStorage.DB]
        FilePath = "PeerBlocks"
        Type = "LvlDBSerial"
        BatchDelaySeconds = 2
        MaxBatchSize = 100
        MaxOpenFiles = 10
        BloomFilterBitsPerKey = 10

[BlockHeaderStorage]
    [BlockHeaderStorage.Cache]
        Name = "BlockHeaderStorage"
        Capacity = 1000
        Type = "SizeLRU"
        SizeInBytes = 3145728 #3MB
    [BlockHeaderStorage.DB]
        FilePath = "BlockHeaders"
        Type = "LvlDBSerial"
        BatchDelaySeconds = 2
        MaxBatchSize = 100
        MaxOpenFiles = 10
        ShardIDProviderType = "BinarySplit"
        NumShards = 4
        BloomFilterBitsPerKey = 10

[BootstrapStorage]
    [BootstrapStorage.Cache]
        Name = "BootstrapStorage"
        Capacity = 1000
        Type = "SizeLRU"
        SizeInBytes = 104857600 #100MB
    [BootstrapStorage.DB]
        FilePath = "BootstrapData"
        Type = "LvlDBSerial"
        BatchDelaySeconds = 2
        MaxBatchSize = 100
        MaxOpenFiles = 10
        BloomFilterBitsPerKey = 10

[MetaBlockStorage]
    [MetaBlockStorage.Cache]
        Name = "MetaBlockStorage"
        Capacity = 1000
        Type = "SizeLRU"
        SizeInBytes = 20971520 #20MB
    [MetaBlockStorage.DB]
        FilePath = "MetaBlock"
        Type = "LvlDBSerial"
        BatchDelaySeconds = 2
        MaxBatchSize = 100
        MaxOpenFiles = 10
        ShardIDProviderType = "BinarySplit"
        NumShards = 4
        BloomFilterBitsPerKey = 10

[ProofsStorage]
    [ProofsStorage.Cache]
        Name = "ProofsStorage"
        Capacity = 1000
        Type = "SizeLRU"
        SizeInBytes = 20971520 #20MB
    [ProofsStorage.DB]
        FilePath = "Proofs"
        Type = "LvlDBSerial"
        BatchDelaySeconds = 2
        MaxBatchSize = 100
        MaxOpenFiles = 10
        BloomFilterBitsPerKey = 10

[ExecutionResultsStorage]
    [ExecutionResultsStorage.Cache]
        Name = "ExecutionResultsStorage"
        Capacity = 1000
        Type = "SizeLRU"
        SizeInBytes = 20971520 #20MB
    [ExecutionResultsStorage.DB]
        FilePath = "ExecutionResults"
        Type = "LvlDBSerial"
        BatchDelaySeconds = 2
        MaxBatchSize = 100
        MaxOpenFiles = 10
        BloomFilterBitsPerKey = 10

[TxStorage]
    [TxStorage.Cache]
        Name = "TxStorage"
        Capacity = 500000
        Type = "SizeLRU"
        SizeInBytes = 209715200 #200MB
    [TxStorage.DB]
        FilePath = "Transactions"
        Type = "LvlDBSerial"
        BatchDelaySeconds = 2
        MaxBatchSize = 30000
        MaxOpenFiles = 10
        ShardIDProviderType = "BinarySplit"
        NumShards = 4
        BloomFilterBitsPerKey = 10

[UnsignedTransactionStorage]
    [UnsignedTransactionStorage.Cache]
        Name = "UnsignedTransactionStorage"
        Capacity = 250000
        Type = "SizeLRU"
        SizeInBytes = 104857600 #100MB
    [UnsignedTransactionStorage.DB]
        FilePath = "UnsignedTransactions"
        Type = "LvlDBSerial"
        BatchDelaySeconds = 2
        MaxBatchSize = 20000
        MaxOpenFiles = 10
        BloomFilterBitsPerKey = 10

[RewardTxStorage]
    [RewardTxStorage.Cache]
        Name = "RewardTxStorage"
        Capacity = 75000
        Type = "SizeLRU"
        SizeInBytes = 52428800 #50MB
    [RewardTxStorage.DB]
        FilePath = "RewardTransactions"
        Type = "LvlDBSerial"
        BatchDelaySeconds = 2
        MaxBatchSize = 20000
        MaxOpenFiles = 10
        BloomFilterBitsPerKey = 10

[SmartContractsStorage]
    [SmartContractsStorage.Cache]
        Name = "SmartContractsStorage"
        Capacity = 1000
        Type = "SizeLRU"
        SizeInBytes = 52428800 #50MB
    [SmartContractsStorage.DB]
        FilePath = "SmartContractsStorage"
        Type = "LvlDBSerial"
        BatchDelaySeconds = 2
        MaxBatchSize = 100
        MaxOpenFiles = 10
        BloomFilterBitsPerKey = 10

[SmartContractsStorageSimulate]
    [SmartContractsStorageSimulate.Cache]
        Name = "SmartContractsStorageSimulate"
        Capacity = 1000
        Type = "SizeLRU"
        SizeInBytes = 52428800 #50MB
    [SmartContractsStorageSimulate.DB]
        FilePath = "SmartContractsStorageSimulate"
        Type = "LvlDBSerial"
        BatchDelaySeconds = 2
        MaxBatchSize = 100
        MaxOpenFiles = 10
        BloomFilterBitsPerKey = 10

[SmartContractsStorageForSCQuery]
    [SmartContractsStorageForSCQuery.Cache]
        Name = "SmartContractsStorageForSCQuery"
        Capacity = 1000
        Type = "SizeLRU"
        SizeInBytes = 52428800 #50MB
    [SmartContractsStorageForSCQuery.DB]
        FilePath = "SmartContractsStorageForSCQuery"
        Type = "LvlDBSerial"
        BatchDelaySeconds = 2
        MaxBatchSize = 100
        MaxOpenFiles = 10
        BloomFilterBitsPerKey = 10

[StatusMetricsStorage]
    [StatusMetricsStorage.Cache]
        Name = "StatusMetricsStorage"
        Capacity = 1000
        Type = "LRU"
    [StatusMetricsStorage.DB]
        FilePath = "StatusMetricsStorageDB"
        Type = "LvlDBSerial"
        BatchDelaySeconds = 2
        MaxBatchSize = 100
        MaxOpenFiles = 10
        BloomFilterBitsPerKey = 10

[TrieEpochRootHashStorage]
    [TrieEpochRootHashStorage.Cache]
        Name = "TrieEpochRootHashCache"
        Capacity = 1000
        Type = "SizeLRU"
        SizeInBytes = 314572800 #300MB
    [TrieEpochRootHashStorage.DB]
        FilePath = "TrieEpochRootHashStorageDB"
        Type = "LvlDBSerial"
        BatchDelaySeconds = 2
        MaxBatchSize = 500
        MaxOpenFiles = 10
        BloomFilterBitsPerKey = 10

[ShardHdrNonceHashStorage]
    [ShardHdrNonceHashStorage.Cache]
        Name = "ShardHdrNonceHashStorage"
        Capacity = 1000
        Type = "SizeLRU"
        SizeInBytes = 3145728 #3MB
    [ShardHdrNonceHashStorage.DB]
        FilePath = "ShardHdrHashNonce"
        Type = "LvlDBSerial"
        BatchDelaySeconds = 2
        MaxBatchSize = 100
        MaxOpenFiles = 10
        BloomFilterBitsPerKey = 10

[MetaHdrNonceHashStorage]
    [MetaHdrNonceHashStorage.Cache]
        Name = "MetaHdrNonceHashStorage"
        Capacity = 1000
        Type = "SizeLRU"
        SizeInBytes = 3145728 #3MB
    [MetaHdrNonceHashStorage.DB]
        FilePath = "MetaHdrHashNonce"
        Type = "LvlDBSerial"
        BatchDelaySeconds = 2
        MaxBatchSize = 100
        MaxOpenFiles = 10
        BloomFilterBitsPerKey = 10

[AccountsTrieStorage]
    [AccountsTrieStorage.Cache]
        Name = "AccountsTrieStorage"
        Capacity = 500000
        Type = "SizeLRU"
        SizeInBytes = 314572800 #300MB
    [AccountsTrieStorage.DB]
        FilePath = "AccountsTrie"
        Type = "LvlDBSerial"
        BatchDelaySeconds = 2
        MaxBatchSize = 45000
        MaxOpenFiles = 10
        ShardIDProviderType = "BinarySplit"
        NumShards = 4

[StateAccessesStorage]
    [StateAccessesStorage.Cache]
        Name = "StateAccessesStorage"
        Capacity = 5000
        Type = "SizeLRU"
        SizeInBytes = 10485760 #10MB
    [StateAccessesStorage.DB]
        FilePath = "StateAccesses"
        Type = "LvlDBSerial"
        BatchDelaySeconds = 2
        MaxBatchSize = 100
        MaxOpenFiles = 10
        BloomFilterBitsPerKey = 10

[PeerAccountsTrieStorage]
    [PeerAccountsTrieStorage.Cache]
        Name = "PeerAccountsTrieStorage"
        Capacity = 5000
        Type = "SizeLRU"
        SizeInBytes = 104857600 #100MB
    [PeerAccountsTrieStorage.DB]
        FilePath = "PeerAccountsTrie"
        Type = "LvlDBSerial"
        BatchDelaySeconds = 2
        MaxBatchSize = 1000
        MaxOpenFiles = 10
        ShardIDProviderType = "BinarySplit"
        NumShards = 4

[EvictionWaitingList]
    #total max size ~ 2 * [(RoothashesSize * 32) + (HashesSize * 32)]
    RootHashesSize = 10000
    HashesSize = 100000
    [EvictionWaitingList.DB]
        FilePath = "EvictionWaitingList"
        Type = "LvlDBSerial"
        BatchDelaySeconds = 2
        MaxBatchSize = 100
        MaxOpenFiles = 10
        BloomFilterBitsPerKey = 10

[TrieStorageManagerConfig]
    PruningBufferLen = 100000
    SnapshotsBufferLen = 1000000
    # SnapshotsGoroutinesPerCore scales the snapshot fan-out with the host: effective goroutines =
    # value * GOMAXPROCS, minimum 4. Keep it low: a deep snapshot run queue can delay waking
    # consensus goroutines
    SnapshotsGoroutinesPerCore = 10

[HeadersPoolConfig]
    MaxHeadersPerShard = 1000
    NumElementsToRemoveOnEviction = 200

[ProofsPoolConfig]
    CleanupNonceDelta = 3
    BucketSize = 100

[BadBlocksCache]
    Name = "BadBlocksCache"
    Capacity = 1000
    Type = "SizeLRU"
    SizeInBytes = 3145728 #3MB

[TxBlockBodyDataPool]
    Name = "TxBlockBodyDataPool"
    Capacity = 100000
    Type = "SizeLRU"
    SizeInBytes = 314572800 #300MB

[PeerBlockBodyDataPool]
    Name = "PeerBlockBodyDataPool"
    Capacity = 1000
    Type = "SizeLRU"
    SizeInBytes = 314572800 #300MB

[TxDataPool]
    Name = "TxDataPool"
    Capacity = 600000
    SizePerSender = 5000
    SizeInBytes = 419430400 #400MB
    SizeInBytesPerSender = 12288000 #12MB
    Type = "TxCache"
    Shards = 16

[TxCacheBounds]
    MaxNumBytesPerSenderUpperBound = 33_554_432 #32MB
    MaxTrackedBlocks = 100
    PropagationGracePeriodMs = 200
    MaxTxNonceDeltaAllowed = 100

[TxCacheSelection]
    SelectionMaxNumTxs = 30000
    SelectionLoopDurationCheckInterval = 10 # chunk (of transactions) size
    SelectionGasBandwidthIncreasePercent = 400
    SelectionGasBandwidthIncreaseScheduledPercent = 260
    SelectionGasRequested = 10_000_000_000

[AOTSelection]
    # Ahead-of-Time transaction selection - pre-selects transactions before consensus round
    Enabled = true
    CacheSize = 10                                          # Number of pre-selection results to cache
    SelectionTimeoutMs = 100                                # Max time for AOT selection in milliseconds

[TrieNodesChunksDataPool]
    Name = "TrieNodesDataPool"
    Capacity = 400
    Type = "SizeLRU"
    SizeInBytes = 104857600 #100MB

[SmartContractDataPool]
    Name = "SmartContractDataPool"
    Capacity = 900000
    Type = "SizeLRU"
    SizeInBytes = 209715200 #200MB

[WhiteListPool]
    Name = "WhiteListPool"
    Capacity = 100000
    Type = "FIFOSharded"
    Shards = 10

[WhiteListerVerifiedTxs]
    Name = "WhiteListerVerifiedTxs"
    Capacity = 50000
    Type = "FIFOSharded"
    Shards = 50

[UnsignedTransactionDataPool]
    Name = "UnsignedTransactionDataPool"
    Capacity = 75000        # per each pair (sourceShard, destinationShard)
    SizeInBytes = 31457280  # 30MB per each pair (sourceShard, destinationShard)
    Shards = 4

[RewardTransactionDataPool]
    Name = "RewardTransactionDataPool"
    Capacity = 75000        # per each pair (metachain, destinationShard)
    SizeInBytes = 26214400  # 25MB per each pair (metachain, destinationShard)
    Shards = 4

[ValidatorInfoPool]
    Name = "ValidatorInfoPool"
    Capacity = 10000
    SizeInBytes = 31457280  #30MB
    Shards = 4

[ExecutedMiniBlocksCache]
    Name = "ExecutedMiniBlocksCache"
    Capacity = 500
    Type = "SizeLRU"
    SizeInBytes = 52428800 # 50MB

[PostProcessTransactionsCache]
    Name = "PostProcessTransactionsCache"
    Capacity = 250000
    Type = "SizeLRU"
    SizeInBytes = 104857600 # 100MB

[HeaderBodyCacheConfig]
    Capacity = 1000

#PublicKeyPeerId represents the main cache used to map MultiversX block signing public keys to their associated peer id's.
[PublicKeyPeerId]
    Name = "PublicKeyPeerId"
    Capacity = 30000
    Type = "LRU"

#PublicKeyShardId is the fallback cache used to map public keys to the shard they belong.
[PublicKeyShardId]
    Name = "PublicKeyShardId"
    Capacity = 30000
    Type = "LRU"

#PublicKeyPIDSignature is the cache that is used to map a public key to a peerId-signature pair.
[PublicKeyPIDSignature]
    Name = "PublicKeyPIDSignature"
    Capacity = 3000
    Type = "LRU"

#PeerIdShardId is the fallback cache used in network sharding to allow direct connection between peer id and shard.
# Used mainly for observers.
[PeerIdShardId]
    Name = "PeerIdShardId"
    Capacity = 30000
    Type = "LRU"

[PeerHonesty]
    Name = "PeerHonesty"
    Capacity = 5000
    Type = "LRU"

[VMOutputCacher]
    Name = "VMOutputCacher"
    Capacity = 10000
    Type = "LRU"

[PeersRatingConfig]
    TopRatedCacheCapacity = 5000
    BadRatedCacheCapacity = 5000

[TrieSyncStorage]
    Capacity = 300000
    SizeInBytes = 104857600 #100MB
    EnableDB = false
    [TrieSyncStorage.DB]
        FilePath = "TrieSyncStorageDB"
        Type = "LvlDBSerial"
        BatchDelaySeconds = 2
        MaxBatchSize = 45000
        MaxOpenFiles = 10
        UseTmpAsFilePath = true
        BloomFilterBitsPerKey = 10

[Antiflood]
    Enabled = true
    MaxAllowedTrieNodeChunks = 10
    TrieNodeChunksInactivityTimeoutInSec = 10
    [[Antiflood.ConfigsByRound]]
        Round = 0
        NumConcurrentResolverJobs = 50
        NumConcurrentResolvingTrieNodesJobs = 3

        [Antiflood.ConfigsByRound.FastReacting]
            IntervalInSeconds = 1
            ReservedPercent   = 20.0
            [Antiflood.ConfigsByRound.FastReacting.PeerMaxInput]
                BaseMessagesPerInterval  = 280
                TotalSizePerInterval = 4194304 #4MB/s
                [Antiflood.ConfigsByRound.FastReacting.PeerMaxInput.IncreaseFactor]
                    Threshold = 10 #if consensus size will exceed this value, then
                    Factor = 1.0   #increase the base value with [factor*consensus size]
            [Antiflood.ConfigsByRound.FastReacting.BlackList]
                ThresholdNumMessagesPerInterval = 1000
                ThresholdSizePerInterval = 8388608 #8MB/s
                NumFloodingRounds = 10
                PeerBanDurationInSeconds = 300

        [Antiflood.ConfigsByRound.SlowReacting]
            IntervalInSeconds = 30
            ReservedPercent   = 20.0
            [Antiflood.ConfigsByRound.SlowReacting.PeerMaxInput]
                BaseMessagesPerInterval = 6000
                TotalSizePerInterval = 18874368 # 18MB/interval
                [Antiflood.ConfigsByRound.SlowReacting.PeerMaxInput.IncreaseFactor]
                    Threshold = 10 #if consensus size will exceed this value, then
                    Factor = 0.0   #increase the base value with [factor*consensus size]
            [Antiflood.ConfigsByRound.SlowReacting.BlackList]
                ThresholdNumMessagesPerInterval = 10000
                ThresholdSizePerInterval = 37748736 # 36MB/interval
                NumFloodingRounds = 2
                PeerBanDurationInSeconds = 3600

        [Antiflood.ConfigsByRound.OutOfSpecs]
            IntervalInSeconds = 1
            ReservedPercent   = 0.0
            [Antiflood.ConfigsByRound.OutOfSpecs.PeerMaxInput]
                BaseMessagesPerInterval = 2000
                TotalSizePerInterval = 10485760 # 10MB/interval
                [Antiflood.ConfigsByRound.OutOfSpecs.PeerMaxInput.IncreaseFactor]
                    Threshold = 0 #if consensus size will exceed this value, then
                    Factor = 0.0     #increase the base value with [factor*consensus size]
            [Antiflood.ConfigsByRound.OutOfSpecs.BlackList]
                ThresholdNumMessagesPerInterval = 3600
                ThresholdSizePerInterval = 12582912 # 12MB/interval
                NumFloodingRounds = 2
                PeerBanDurationInSeconds = 3600

        [Antiflood.ConfigsByRound.PeerMaxOutput]
            [Antiflood.ConfigsByRound.PeerMaxOutput.PeerMaxInput]
                BaseMessagesPerInterval  = 150
                TotalSizePerInterval     = 2097152 #2MB/s

        [Antiflood.ConfigsByRound.Cache]
            Name = "Antiflood"
            Capacity = 7000
            Type = "LRU"
        [Antiflood.ConfigsByRound.Topic]
            DefaultMaxMessagesPerSec = 15000
            MaxMessages = [{ Topic = "shardBlocks*", NumMessagesPerSec = 30 },
                { Topic = "metachainBlocks", NumMessagesPerSec = 30 }]

        [Antiflood.ConfigsByRound.TxAccumulator]
            # MaxAllowedTimeInMilliseconds is used as a time frame in which the node gathers transactions.
            # After this period, collected transactions will be sent on the p2p topics
            MaxAllowedTimeInMilliseconds = 250
            # MaxDeviationTimeInMilliseconds represents the time in miliseconds that will cause the effectual time frame be
            # less than the specified max value. This is used to create desynchronizations between senders as to not
            # clutter the network exactly in the same moment
            MaxDeviationTimeInMilliseconds = 25

    [[Antiflood.ConfigsByRound]]
        Round = 32157661
        NumConcurrentResolverJobs = 50
        NumConcurrentResolvingTrieNodesJobs = 3

        [Antiflood.ConfigsByRound.FastReacting]
            IntervalInSeconds = 1
            ReservedPercent   = 20.0
            [Antiflood.ConfigsByRound.FastReacting.PeerMaxInput]
                BaseMessagesPerInterval  = 2800
                TotalSizePerInterval = 41943040 # 40MB/s
                [Antiflood.ConfigsByRound.FastReacting.PeerMaxInput.IncreaseFactor]
                    Threshold = 10 #if consensus size will exceed this value, then
                    Factor = 1.0   #increase the base value with [factor*consensus size]
            [Antiflood.ConfigsByRound.FastReacting.BlackList]
                ThresholdNumMessagesPerInterval = 10000
                ThresholdSizePerInterval = 83886080 #80MB/s
                NumFloodingRounds = 10
                PeerBanDurationInSeconds = 300

        [Antiflood.ConfigsByRound.SlowReacting]
            IntervalInSeconds = 30
            ReservedPercent   = 20.0
            [Antiflood.ConfigsByRound.SlowReacting.PeerMaxInput]
                BaseMessagesPerInterval = 60000
                TotalSizePerInterval = 188743680 # 180MB/interval
                [Antiflood.ConfigsByRound.SlowReacting.PeerMaxInput.IncreaseFactor]
                    Threshold = 10 #if consensus size will exceed this value, then
                    Factor = 0.0   #increase the base value with [factor*consensus size]
            [Antiflood.ConfigsByRound.SlowReacting.BlackList]
                ThresholdNumMessagesPerInterval = 100000
                ThresholdSizePerInterval = 377487360 # 360MB/interval
                NumFloodingRounds = 2
                PeerBanDurationInSeconds = 3600

        [Antiflood.ConfigsByRound.OutOfSpecs]
            IntervalInSeconds = 1
            ReservedPercent   = 0.0
            [Antiflood.ConfigsByRound.OutOfSpecs.PeerMaxInput]
                BaseMessagesPerInterval = 20000
                TotalSizePerInterval = 104857600 # 100MB/interval
                [Antiflood.ConfigsByRound.OutOfSpecs.PeerMaxInput.IncreaseFactor]
                    Threshold = 0 #if consensus size will exceed this value, then
                    Factor = 0.0     #increase the base value with [factor*consensus size]
            [Antiflood.ConfigsByRound.OutOfSpecs.BlackList]
                ThresholdNumMessagesPerInterval = 36000
                ThresholdSizePerInterval = 125829120 # 120MB/interval
                NumFloodingRounds = 2
                PeerBanDurationInSeconds = 3600

        [Antiflood.ConfigsByRound.PeerMaxOutput]
            [Antiflood.ConfigsByRound.PeerMaxOutput.PeerMaxInput]
                BaseMessagesPerInterval  = 1500
                TotalSizePerInterval     = 20971520 #20MB/s

        [Antiflood.ConfigsByRound.Cache]
            Name = "Antiflood"
            Capacity = 70000
            Type = "LRU"
        [Antiflood.ConfigsByRound.Topic]
            DefaultMaxMessagesPerSec = 150000
            MaxMessages = [{ Topic = "shardBlocks*", NumMessagesPerSec = 300 },
                { Topic = "metachainBlocks", NumMessagesPerSec = 300 }]

        [Antiflood.ConfigsByRound.TxAccumulator]
            # MaxAllowedTimeInMilliseconds is used as a time frame in which the node gathers transactions.
            # After this period, collected transactions will be sent on the p2p topics
            MaxAllowedTimeInMilliseconds = 80
            # MaxDeviationTimeInMilliseconds represents the time in miliseconds that will cause the effectual time frame be
            # less than the specified max value. This is used to create desynchronizations between senders as to not
            # clutter the network exactly in the same moment
            MaxDeviationTimeInMilliseconds = 25
    # Antiflood config ends here for Supernova

[WebServerAntiflood]
    WebServerAntifloodEnabled = true
    # SimultaneousRequests represents the number of concurrent requests accepted by the web server
    # this is a global throttler that acts on all http connections regardless of the originating source
    SimultaneousRequests = 100
    # SameSourceRequests defines how many requests are allowed from the same source in the specified
    # time frame (SameSourceResetIntervalInSec)
    SameSourceRequests = 10000
    # SameSourceResetIntervalInSec time frame between counter reset, in seconds
    SameSourceResetIntervalInSec = 1
    # TrieOperationsDeadlineMilliseconds represents the maximum duration that an API call targeting a trie operation
    # can take.
    TrieOperationsDeadlineMilliseconds = 10000
    # GetAddressesBulkMaxSize represents the maximum number of addresses to be fetched in a bulk per API request. 0 means unlimited
    GetAddressesBulkMaxSize = 100
    # VmQueryDelayAfterStartInSec represents the number of seconds to wait when starting node before accepting vm query requests
    VmQueryDelayAfterStartInSec = 120
    # EndpointsThrottlers represents a map for maximum simultaneous go routines for an endpoint
    EndpointsThrottlers = [{ Endpoint = "/transaction/:hash", MaxNumGoRoutines = 10 },
                           { Endpoint = "/transaction/send", MaxNumGoRoutines = 2 },
                           { Endpoint = "/transaction/simulate", MaxNumGoRoutines = 1 },
                           { Endpoint = "/transaction/send-multiple", MaxNumGoRoutines = 2 }]

[AddressPubkeyConverter]
    Length = 32
    Type = "bech32"
    SignatureLength = 64
    Hrp = "erd"

[ValidatorPubkeyConverter]
    Length = 96
    Type = "hex"
    SignatureLength = 48

[Hasher]
   Type = "blake2b"

[MultisigHasher]
   Type = "blake2b"

[TxSignHasher]
    Type = "keccak"

# The main marshalizer, used in internodes communication
# Type identifies the marshalizer
# SizeCheckDelta the maximum allow drift between the input data buffer and
#     the reencoded version (in percents).
#     0 disables the feature.
[Marshalizer]
   Type = "gogo protobuf"
   SizeCheckDelta = 10

# The marshalizer used for smartcontracts data exchange
[VmMarshalizer]
   Type = "json"

# The marshalizer used in transaction signing
[TxSignMarshalizer]
   Type = "json"

[EpochStartConfig]
    GenesisEpoch = 0
    # Min and Max ShuffledOutRestartThreshold represents the minimum and maximum duration of an epoch (in percentage) after a node which
    # has been shuffled out has to restart its process in order to start in a new shard
    MinShuffledOutRestartThreshold = 0.01
    MaxShuffledOutRestartThreshold = 0.05

    MinNumConnectedPeersToStart       = 6
    MinNumOfPeersToConsiderBlockValid = 6

# ResourceStats, if enabled, will output in a folder called "stats"
# resource statistics. For example: number of active go routines, memory allocation, number of GC sweeps, etc.
# RefreshIntervalInSec will tell how often a new line containing stats should be added in stats file
[ResourceStats]
    Enabled = true
    RefreshIntervalInSec = 30

[ValidatorStatistics]
    CacheRefreshIntervalInSec = 60

# Consensus type which will be used (the current implementation can manage "bn" and "bls")
# When consensus type is "bls" the multisig hasher type should be "blake2b"
[Consensus]
    Type = "bls"

[NTPConfig]
    Hosts = ["time.google.com", "time.cloudflare.com",  "time.apple.com"]
    Port = 123
    TimeoutMilliseconds = 100
    SyncPeriodSeconds = 3600
    Version = 0  # Setting 0 means 'use default value'
    # OutOfBoundsThreshold defines the threshold in milliseconds for checking out of bound
    # limit in ntp syncer
    OutOfBoundsThreshold = 120

[StateTriesConfig]
    SnapshotsEnabled = true
    AccountsStatePruningEnabled = false
    PeerStatePruningEnabled = true
    MaxStateTrieLevelInMemory = 5
    MaxPeerTrieLevelInMemory = 5
    StateStatisticsEnabled = false

[TrieLeavesRetrieverConfig]
    Enabled = false
    MaxSizeInBytes = 10485760 #10MB

[StateAccessesCollectorConfig]
    TypesToCollect = []          # These can be "READ","WRITE".
    SaveToStorage = false
    WithAccountChanges = false

[BlockSizeThrottleConfig]
    MinSizeInBytes = 104857 # 104857 is 10% from 1MB
    MaxSizeInBytes = 943718 # 943718 is 90% from 1MB
    MaxExecResSizeInBytes = 104857 # 104857 is 10% from 1MB

[VirtualMachine]
    [VirtualMachine.Execution]
        TimeOutForSCExecutionInMilliseconds = 10000 # 10 seconds = 10000 milliseconds
        WasmerSIGSEGVPassthrough            = false # must be false for release
        WasmVMVersions = [
            { StartEpoch = 0, Version = "v1.2" },
            { StartEpoch = 326, Version = "v1.3" },
            { StartEpoch = 432, Version = "v1.4" },
            { StartEpoch = 1265, Version = "v1.5" },
        ]
        TransferAndExecuteByUserAddresses = [ # TODO: set real contract addresses for all shards
            "erd1qqqqqqqqqqqqqpgqr46jrxr6r2unaqh75ugd308dwx5vgnhwh47qtvepe3", #shard 0
        ]

    [VirtualMachine.Querying]
        NumConcurrentVMs = 1
        TimeOutForSCExecutionInMilliseconds = 10000 # 10 seconds = 10000 milliseconds
        WasmerSIGSEGVPassthrough            = false # must be false for release
        WasmVMVersions = [
            { StartEpoch = 0, Version = "v1.2" },
            { StartEpoch = 326, Version = "v1.3" },
            { StartEpoch = 432, Version = "v1.4" },
            { StartEpoch = 1265, Version = "v1.5" },
        ]
        TransferAndExecuteByUserAddresses = [ # TODO: set real contract addresses for all shards
            "erd1qqqqqqqqqqqqqpgqr46jrxr6r2unaqh75ugd308dwx5vgnhwh47qtvepe3",
        ]

    [VirtualMachine.GasConfig]
        # The following values define the maximum amount of gas to be allocated for VM Queries coming from API
        # If set to 0, then MaxUInt64 will be used
        ShardMaxGasPerVmQuery = 1500000000  #1.5b
        MetaMaxGasPerVmQuery = 0  #unlimited

[BuiltInFunctions]
    AutomaticCrawlerAddresses =[
        "erd13cv2nllvka35dshazqxtcym8vyamnmjay26nzcjswnjyxxpny7yq6twx0v", #shard 0
        "erd14zpxzaf3s00j6s4ke2ct475dk9285ekejujvtkt4h6azm2rfkfdsyjqkk4", #shard 1
        "erd1zj06ewmmmm2ntng4d8art4ta8fz0n5xr4f0yn9knuf2k8mm7gzhqqf74cr", #shard 2
    ]
    MaxNumAddressesInTransferRole = 100
    DNSV2Addresses =[
        "erd1qqqqqqqqqqqqqpgqw0klqcd9e7srnf83katehmgsm7jneu7zawhstk3zde",
    ]

[[HardforkRoundExclusions]]
    StartRound = 33384827
    EndRound = 34020551

[[HardforkRoundExclusions]]
    StartRound = 34047051 # WED, 23 Sep 2026 21:00:00 UTC
    EndRound = 34158051   # Thu, 24 Sep 2026 15:30:00 UTC

[HardforkRecoveryCheckpoint]
    Enabled = true
    Round = 33384826

[[HardforkRecoveryCheckpoint.Headers]]
    ShardID = 4294967295
    Hash = "1f036cc21c9cb9fde00bad869666d9dd9c6b12278b55df5e07ce67c4db8e41a6"

[[HardforkRecoveryCheckpoint.Headers]]
    ShardID = 0
    Hash = "8c5b2e8a75ce938960b63503d98b88ca670286cb4cf60d16088ea6a7dae9f1a2"

[[HardforkRecoveryCheckpoint.Headers]]
    ShardID = 1
    Hash = "48a9fb558d27902d96bd4e8a09c1efab5e9231f98662068b95240943595cf850"

[[HardforkRecoveryCheckpoint.Headers]]
    ShardID = 2
    Hash = "a0b6f4347a26b90599ae64a7ac910d87df4b55a1992611df3a57b63e65c3593c"


[Hardfork]
    EnableTrigger = true
    EnableTriggerFromP2P = true
    PublicKeyToListenFrom = "6a02b93375e78aed4e0e3369ef2182dfc060eea01df640eacc5eca5f759f62c8271fbbf90863e896e2453384118be20179433cb1dfc1bd8df962c80f3da94ea42dffaf70025b6fd6a5b4814bc4b15cf6751c990fe21d392f1bc88c15bd354a8c"
    CloseAfterExportInMinutes = 10000
    AfterHardFork = false
    ImportFolder = "export"
    StartRound = 10000
    StartNonce = 10000
    StartEpoch = 100
    GenesisTime = 0
    ValidatorGracePeriodInEpochs = 1 #defines how long is the rating computation disabled after hardfork
    [Hardfork.ExportStateStorageConfig]
        [Hardfork.ExportStateStorageConfig.Cache]
            Name = "HardFork.ExportStateStorageConfig"
            Capacity = 5000
            Type = "LRU"
        [Hardfork.ExportStateStorageConfig.DB]
            FilePath = "ExportStateStorage/MainDB"
            Type = "LvlDBSerial"
            BatchDelaySeconds = 2
            MaxBatchSize = 1000
            MaxOpenFiles = 10
            BloomFilterBitsPerKey = 10
    [Hardfork.ExportKeysStorageConfig]
        [Hardfork.ExportKeysStorageConfig.Cache]
            Name = "HardFork.ExportKeysStorageConfig"
            Capacity = 5000
            Type = "LRU"
        [Hardfork.ExportKeysStorageConfig.DB]
            FilePath = "ExportKeysStorageConfig/MainDB"
            Type = "LvlDBSerial"
            BatchDelaySeconds = 2
            MaxBatchSize = 1000
            MaxOpenFiles = 10
            BloomFilterBitsPerKey = 10
    [Hardfork.ExportTriesStorageConfig]
        [Hardfork.ExportTriesStorageConfig.Cache]
            Name = "HardFork.ExportTriesStorageConfig"
            Capacity = 5000
            Type = "LRU"
        [Hardfork.ExportTriesStorageConfig.DB]
            FilePath = "ExportTrieStorage/MainTrie"
            Type = "LvlDBSerial"
            BatchDelaySeconds = 2
            MaxBatchSize = 1000
            MaxOpenFiles = 10
            BloomFilterBitsPerKey = 10
    [Hardfork.ImportStateStorageConfig]
        [Hardfork.ImportStateStorageConfig.Cache]
            Name = "HardFork.ImportStateStorageConfig"
            Capacity = 5000
            Type = "LRU"
        [Hardfork.ImportStateStorageConfig.DB]
            FilePath = "ExportStateStorage/MainDB"
            Type = "LvlDBSerial"
            BatchDelaySeconds = 2
            MaxBatchSize = 1000
            MaxOpenFiles = 10
            BloomFilterBitsPerKey = 10
    [Hardfork.ImportKeysStorageConfig]
        [Hardfork.ImportKeysStorageConfig.Cache]
            Name = "HardFork.ImportKeysStorageConfig"
            Capacity = 5000
            Type = "LRU"
        [Hardfork.ImportKeysStorageConfig.DB]
            FilePath = "ExportKeysStorageConfig/MainDB"
            Type = "LvlDBSerial"
            BatchDelaySeconds = 2
            MaxBatchSize = 1000
            MaxOpenFiles = 10
            BloomFilterBitsPerKey = 10

[Debug]
    [Debug.InterceptorResolver]
        Enabled = false
        CacheSize = 10000
        EnablePrint	= false
        IntervalAutoPrintInSeconds = 20
        NumRequestsThreshold = 9
        NumResolveFailureThreshold = 3
        DebugLineExpiration = 10 #Will remove the debug line after a `DebugLineExpiration` number of prints
        [Debug.InterceptorResolver.BroadcastStatistics]
            Enabled = false
            # "intercepted tx", "intercepted reward tx", "intercepted unsigned tx", "intercepted header", ...
            Messages = ["intercepted tx"]
    [Debug.Antiflood]
        Enabled = true
        CacheSize = 10000
        IntervalAutoPrintInSeconds = 20
    [Debug.ShuffleOut]
        CallGCWhenShuffleOut = true
        ExtraPrintsOnShuffleOut = true
        DoProfileOnShuffleOut = true
    [Debug.EpochStart]
        # dumps every goroutine stack on each epoch start, which stops the world and floods the log
        # exactly while the epoch start snapshot runs; enable only when investigating goroutine leaks
        GoRoutineAnalyserEnabled = false
        ProcessDataTrieOnCommitEpoch = false
    [Debug.Process]
        Enabled = false
        DebuggingLogLevel = "*:DEBUG,p2p:TRACE,debug:DEBUG,process:TRACE,intercept:TRACE"
        GoRoutinesDump = true
        PollingTimeInSeconds = 240 # 4 minutes
        # setting this to 0 disables the automatic revert of the log level
        RevertLogLevelTimeInSeconds = 600 # 10 minutes

[Health]
    IntervalVerifyMemoryInSeconds = 30
    IntervalDiagnoseComponentsInSeconds = 30
    IntervalDiagnoseComponentsDeeplyInSeconds = 120
    MemoryUsageToCreateProfiles = 3221225472 # 3 GB
    NumMemoryUsageRecordsToKeep = 100
    FolderPath = "health-records"

[SoftwareVersionConfig]
    StableTagLocation = "https://api.github.com/repos/multiversx/mx-chain-mainnet-config/releases/latest"
    PollingIntervalInMinutes = 65

[GatewayMetricsConfig]
    URL = "https://gateway.multiversx.com"

[LogsAndEvents]
    SaveInStorageEnabled = false
    [LogsAndEvents.TxLogsStorage.Cache]
        Name = "TxLogsStorage"
        Capacity = 1000
        Type = "SizeLRU"
        SizeInBytes = 20971520 #20MB
    [LogsAndEvents.TxLogsStorage.DB]
        FilePath = "Logs"
        Type = "LvlDBSerial"
        BatchDelaySeconds = 2
        MaxBatchSize = 100
        MaxOpenFiles = 10
        BloomFilterBitsPerKey = 10

[DbLookupExtensions]
    Enabled = false
    DbLookupMaxActivePersisters = 10
    [DbLookupExtensions.MiniblocksMetadataStorageConfig.Cache]
        Name = "DbLookupExtensions.MiniblocksMetadataStorage"
        Capacity = 20000
        Type = "LRU"
    [DbLookupExtensions.MiniblocksMetadataStorageConfig.DB]
        FilePath = "DbLookupExtensions/MiniblocksMetadata"
        Type = "LvlDBSerial"
        BatchDelaySeconds = 2
        MaxBatchSize = 20000
        MaxOpenFiles = 10
        BloomFilterBitsPerKey = 10
    [DbLookupExtensions.MiniblockHashByTxHashStorageConfig.Cache]
        Name = "DbLookupExtensions.MiniblockHashByTxHashStorage"
        Capacity = 20000
        Type = "LRU"
    [DbLookupExtensions.MiniblockHashByTxHashStorageConfig.DB]
        FilePath = "DbLookupExtensions_MiniblockHashByTxHash"
        Type = "LvlDBSerial"
        BatchDelaySeconds = 2
        MaxBatchSize = 20000
        MaxOpenFiles = 10
        ShardIDProviderType = "BinarySplit"
        NumShards = 4
        BloomFilterBitsPerKey = 10
    [DbLookupExtensions.EpochByHashStorageConfig.Cache]
        Name = "DbLookupExtensions.EpochByHashStorage"
        Capacity = 20000
        Type = "LRU"
    [DbLookupExtensions.EpochByHashStorageConfig.DB]
        FilePath = "DbLookupExtensions_EpochByHash"
        Type = "LvlDBSerial"
        BatchDelaySeconds = 2
        MaxBatchSize = 20000
        MaxOpenFiles = 10
        ShardIDProviderType = "BinarySplit"
        NumShards = 4
        BloomFilterBitsPerKey = 10
    [DbLookupExtensions.ResultsHashesByTxHashStorageConfig.Cache]
        Name = "DbLookupExtensions.ResultsHashesByTxHashStorage"
        Capacity = 20000
        Type = "LRU"
    [DbLookupExtensions.ResultsHashesByTxHashStorageConfig.DB]
        FilePath = "DbLookupExtensions_ResultsHashesByTx"
        Type = "LvlDBSerial"
        BatchDelaySeconds = 2
        MaxBatchSize = 20000
        MaxOpenFiles = 10
        BloomFilterBitsPerKey = 10
    [DbLookupExtensions.ESDTSuppliesStorageConfig.Cache]
        Name = "DbLookupExtensions.ESDTSuppliesStorage"
        Capacity = 20000
        Type = "LRU"
    [DbLookupExtensions.ESDTSuppliesStorageConfig.DB]
        FilePath = "DbLookupExtensions_ESDTSupplies"
        Type = "LvlDBSerial"
        BatchDelaySeconds = 2
        MaxBatchSize = 20000
        MaxOpenFiles = 10
        BloomFilterBitsPerKey = 10
    [DbLookupExtensions.RoundHashStorageConfig.Cache]
        Name = "DbLookupExtensions.RoundHashStorage"
        Capacity = 20000
        Type = "LRU"
    [DbLookupExtensions.RoundHashStorageConfig.DB]
        FilePath = "DbLookupExtensions_RoundHash"
        Type = "LvlDBSerial"
        BatchDelaySeconds = 2
        MaxBatchSize = 20000
        MaxOpenFiles = 10
        BloomFilterBitsPerKey = 10

[Logs]
    LogFileLifeSpanInMB = 1024 # 1GB
    LogFileLifeSpanInSec = 86400 # 1 day

[TrieSync]
    NumConcurrentTrieSyncers  = 200
    MaxHardCapForMissingNodes = 5000
    #available versions: 1, 2 and 3. 1 is the initial version, 2 is updated, more efficient version employing 2 lists
    #the 3-rd one uses depth-first algorithm which keeps the memory consumption low
    TrieSyncerVersion         = 3
    CheckNodesOnDisk          = false

[Requesters]
    NumCrossShardPeers  = 2
    NumTotalPeers       = 3 # NumCrossShardPeers + num intra shard
    NumFullHistoryPeers = 3
    RequestProofByNonceDelayMs = 100 # delay proof requests by nonce to allow the header to be received first

[HeartbeatV2]
    PeerAuthenticationTimeBetweenSendsInSec          = 7200  # 2h
    PeerAuthenticationTimeBetweenSendsWhenErrorInSec = 60    # 1min
    PeerAuthenticationTimeThresholdBetweenSends      = 0.1   # 10%   # max random threshold between messages, representing a percent of PeerAuthenticationTimeBetweenSendsInSec
    HeartbeatTimeBetweenSendsInSec                   = 300   # 5min
    HeartbeatTimeBetweenSendsDuringBootstrapInSec    = 300   # 5min
    HeartbeatTimeBetweenSendsWhenErrorInSec          = 60    # 1min
    HeartbeatTimeThresholdBetweenSends               = 0.1   # 10%        # max random threshold between messages, representing a percent of HeartbeatTimeBetweenSendsInSec
    HeartbeatExpiryTimespanInSec                     = 14400 # 4h         # heartbeat message max age allowed
    MinPeersThreshold                                = 0.8   # 80%        # min threshold of peers to consider enough peer auths received
    DelayBetweenPeerAuthenticationRequestsInSec      = 5     # 5sec       # delay between requests
    PeerAuthenticationMaxTimeoutForRequestsInSec     = 7200  # 2h         # max timeout allowed to receive peer auth messages from peers
    PeerShardTimeBetweenSendsInSec                   = 7200  # 2h
    PeerShardTimeThresholdBetweenSends               = 0.1   # 10%        # max random threshold between messages, representing a percent of PeerShardTimeBetweenSendsInSec
    MaxMissingKeysInRequest                          = 500                # max number of missing keys allowed in a request
    MaxDurationPeerUnresponsiveInSec                 = 900   # 15min      # max duration after which a peer is considered inactive
    HideInactiveValidatorIntervalInSec               = 3600  # 1h         # time that an inactive validator is returned through api
    HardforkTimeBetweenSendsInSec                    = 60    # 1min       # time between hardfork messages
    TimeBetweenConnectionsMetricsUpdateInSec         = 30    # 30sec      # time between consecutive connections metrics updates
    TimeToReadDirectConnectionsInSec                 = 15    # 15sec      # time between consecutive peer shard mapper updates with direct connections
    PeerAuthenticationTimeBetweenChecksInSec         = 6     # 6sec
    [HeartbeatV2.HeartbeatPool]
        Name = "HeartbeatPool"
        Capacity = 50000
        Type = "SizeLRU"
        SizeInBytes = 314572800 #300MB

[InterceptedDataVerifier]
    EnableCaching = true
    CacheSpanInSec = 30
    CacheExpiryInSec = 30

[DirectSentTransactions]
    CacheSpanInSec = 30
    CacheExpiryInSec = 30

[ExecutionResultInclusionEstimator]
    # Safety margin = 110 -> 110% -> 10% buffer
    SafetyMargin = 110
    # Maximum execution results a single block may carry (0 = unlimited)
    MaxResultsPerBlock = 20