[logging]
    # Logging level. High log levels might impact performance. 0: ERROR, 1: WARN, 2: INFO, 3: DEBUG, 4: TRACE
    level = 2

[cli]
    approved_community_charter_file_path = "config/approved_community_charter.txt"

[api]
    # max number of future periods considered during requests
    draw_lookahead_period_count = 10
    # port on which the node API listens for admin and node management requests. Dangerous if publicly exposed. Bind to "[::1]:port" for IPv6
    bind_private = "127.0.0.1:33034"
    # port on which the node API listens for public requests. Can be exposed to the Internet. Bind to "[::]:port" for IPv6
    bind_public = "0.0.0.0:33035"
    # port on which the node API(V2) listens for HTTP requests and WebSockets subscriptions. Can be exposed to the Internet. Bind to "[::]:port" for IPv6
    bind_api = "0.0.0.0:33036"
    # max number of arguments per RPC call
    max_arguments = 128
    # path to the openrpc specification file used in `rpc.discover` method
    openrpc_spec_path = "base_config/openrpc.json"
    # maximum size in bytes of a request. Defaults to 50MB
    max_request_body_size = 52428800
    # maximum size in bytes of a response. Defaults to 50MB
    max_response_body_size = 52428800
    # maximum number of incoming connections allowed
    max_connections = 100
    # maximum number of subscriptions per connection
    max_subscriptions_per_connection = 100
    # max length for logging for requests and responses. Logs bigger than this limit will be truncated
    max_log_length = 4096
    # host filtering
    allow_hosts = []
    # batch request limit. 0 means disabled
    batch_request_limit = 16
    # the interval at which `Ping` frames are submitted in milliseconds
    ping_interval = 60000
    # whether to enable HTTP.
    enable_http = true
    # whether to enable WS.
    enable_ws = false
    # whether to broadcast for blocks, endorsements and operations
    enable_broadcast = false
    # deferred credits delta (in milliseconds)
    deferred_credits_delta = 7776000000 # ~ 3 months (90×24×60×60×1000) in milliseconds

[grpc]
    [grpc.public]
        # whether to enable gRPC
        enabled = true
        # whether to add HTTP 1 layer
        accept_http1 = false
        # whether to enable CORS. works only if `accept_http1` is true
        enable_cors = false
        # whether to enable gRPC health service
        enable_health = true
        # whether to enable gRPC reflection(introspection)
        enable_reflection = true
        # whether to enable TLS
        enable_tls = false
        # whether to enable mTLS (requires `enable_tls` to be true)
        enable_mtls = false
        # whether to generate a self-signed certificate if none is provided(ignored if `enable_tls` is false)
        generate_self_signed_certificates = true
        # list of subject alternative names for the server certificate(requires `generate_self_signed_certificates` to be true)
        subject_alt_names = []
        # bind for the Massa gRPC API
        bind = "0.0.0.0:33037"
        # which compression encodings does the server accept for requests
        accept_compressed = "Gzip"
        # which compression encodings might the server use for responses
        send_compressed = "Gzip"
        # limits the maximum size of a decoded message. Defaults to 50MB
        max_decoding_message_size = 52428800
        # limits the maximum size of an encoded message. Defaults to 50MB
        max_encoding_message_size = 52428800
        # limits the maximum size of streaming channel
        max_channel_size = 128
        # set a timeout on for all request handlers in seconds. Defaults to 60s
        timeout = 60
        # sets the maximum frame size to use for HTTP2(must be within 16384(16KB) and 16777215(16MB)). Defaults to 16KB
        max_frame_size = 16384
        # set the concurrency limit applied to on requests inbound per connection. Defaults to 32
        concurrency_limit_per_connection = 100
        # sets the SETTINGS_MAX_CONCURRENT_STREAMS spec option for HTTP2 connections
        max_concurrent_streams = 100
        # max number of arguments per gRPC request
        max_arguments = 128
        # set the value of `TCP_NODELAY` option for accepted connections. Enabled by default
        tcp_nodelay = true
        # max number of future periods considered during requests
        draw_lookahead_period_count = 10
        # max number of addresses that can be included in a single request
        max_addresses_per_request = 50
        # max number of slot ranges that can be included in a single request
        max_slot_ranges_per_request = 50
        # max number of block ids that can be included in a single request
        max_block_ids_per_request = 50
        # max number of endorsement ids that can be included in a single request
        max_endorsement_ids_per_request = 100
        # max number of operation ids that can be included in a single request
        max_operation_ids_per_request = 250
        # max op datastore entries per request
        max_datastore_entries_per_request = 128
        # max number of filters that can be included in a single request
        max_filters_per_request = 32
        # max number of query items that can be included in a single request
        max_query_items_per_request = 128
        # certificate authority root path
        certificate_authority_root_path = "config/tls_public_ca.pem"
        # server certificate path
        server_certificate_path = "config/tls_public_server.pem"
        # server private key path
        server_private_key_path = "config/tls_public_server.key"
        # client certificate authority root path
        client_certificate_authority_root_path = "config/tls_public_client_ca.pem"
        # client certificate path
        client_certificate_path = "../massa-client/config/tls_public_client.pem"
        # client private key path
        client_private_key_path = "../massa-client/config/tls_public_client.key"
    [grpc.private]
        # whether to enable gRPC
        enabled = true
        # whether to add HTTP 1 layer
        accept_http1 = false
        # whether to enable CORS. works only if `accept_http1` is true
        enable_cors = false
        # whether to enable gRPC health service
        enable_health = true
        # whether to enable gRPC reflection(introspection)
        enable_reflection = true
        # whether to enable TLS
        enable_tls = false
        # whether to enable mTLS (requires `enable_tls` to be true)
        enable_mtls = true
        # whether to generate a self-signed certificate if none is provided(ignored if `enable_tls` is false)
        generate_self_signed_certificates = true
        # list of subject alternative names for the server certificate(requires `generate_self_signed_certificates` to be true)
        subject_alt_names = []
        # bind for the Massa gRPC API
        bind = "127.0.0.1:33038"
        # which compression encodings does the server accept for requests
        accept_compressed = "Gzip"
        # which compression encodings might the server use for responses
        send_compressed = "Gzip"
        # limits the maximum size of a decoded message. Defaults to 50MB
        max_decoding_message_size = 52428800
        # limits the maximum size of an encoded message. Defaults to 50MB
        max_encoding_message_size = 52428800
        # limits the maximum size of streaming channel
        max_channel_size = 128
        # set a timeout on for all request handlers in seconds. Defaults to 60s
        timeout = 60
        # sets the maximum frame size to use for HTTP2(must be within 16384(16KB) and 16777215(16MB)). Defaults to 16KB
        max_frame_size = 16384
        # set the concurrency limit applied to on requests inbound per connection. Defaults to 32
        concurrency_limit_per_connection = 100
        # sets the SETTINGS_MAX_CONCURRENT_STREAMS spec option for HTTP2 connections
        max_concurrent_streams = 100
        # max number of arguments per gRPC request
        max_arguments = 128
        # set the value of `TCP_NODELAY` option for accepted connections. Enabled by default
        tcp_nodelay = true
        # max number of future periods considered during requests
        draw_lookahead_period_count = 10
        # max number of addresses that can be included in a single request
        max_addresses_per_request = 50
        # max number of slot ranges that can be included in a single request
        max_slot_ranges_per_request = 50
        # max number of block ids that can be included in a single request
        max_block_ids_per_request = 50
        # max number of endorsement ids that can be included in a single request
        max_endorsement_ids_per_request = 100
        # max number of operation ids that can be included in a single request
        max_operation_ids_per_request = 250
        # max op datastore entries per request
        max_datastore_entries_per_request = 128
        # max number of filters that can be included in a single request
        max_filters_per_request = 32
        # max number of query items that can be included in a single request
        max_query_items_per_request = 128
        # certificate authority root path
        certificate_authority_root_path = "config/tls_private_ca.pem"
        # server certificate path
        server_certificate_path = "config/tls_private_server.pem"
        # server private key path
        server_private_key_path = "config/tls_private_server.key"
        # client certificate authority root path
        client_certificate_authority_root_path = "config/tls_private_client_ca.pem"
        # client certificate path
        client_certificate_path = "../massa-client/config/tls_private_client.pem"
        # client private key path
        client_private_key_path = "../massa-client/config/tls_private_client.key"

[execution]
    # max number of generated events kept in RAM
    max_final_events = 10000
    # maximum length of the read-only execution requests queue
    readonly_queue_length = 10
    # by how many milliseconds should the execution lag behind real time
    # higher values increase speculative execution lag but improve performance
    cursor_delay = 2000
    # duration of the statistics time window in milliseconds
    stats_time_window_duration = 60000
    # maximum allowed gas for read only executions
    max_read_only_gas = 4_294_967_295
    # gas cost for ABIs
    abi_gas_costs_file = "base_config/gas_costs/abi_gas_costs.json"
    # gas cost for wasm operator
    wasm_gas_costs_file = "base_config/gas_costs/wasm_gas_costs.json"
    # path to the hard drive cache storage
    hd_cache_path = "storage/cache/rocks_db"
    # maximum number of entries we want to keep in the LRU cache
    # in the worst case scenario this is equivalent to 2Gb
    lru_cache_size = 200
    # maximum number of entries we want to keep in the HD cache
    # in the worst case scenario this is equivalent to 20Gb
    hd_cache_size = 2000
    # amount of entries removed when `hd_cache_size` is reached
    snip_amount = 10
    # slot execution outputs channel capacity
    broadcast_slot_execution_output_channel_capacity = 5000
    # Enable execution-traces (detailed execution info like SC abi calls) with: --features execution-trace
    # slot execution traces channel capacity
    broadcast_slot_execution_traces_channel_capacity = 5000
    # Max slots execution traces to keep in cache
    execution_traces_limit = 320
    # path to the event cache storage
    event_cache_path = "storage/event_cache/rocks_db"
    # maximum number of entries we want to keep in the Event cache (~ 10 Gb)
    event_cache_size = 20071520
    # amount of entries removed when `event_cache_size` is reached
    event_snip_amount = 10
    # maximum number of events return by a query
    max_event_per_query = 7000

[ledger]
    # path to the initial ledger
    initial_ledger_path = "base_config/initial_ledger.json"
    # path to the disk ledger db directory
    disk_ledger_path = "storage/ledger/rocks_db"
    # length of the changes history. Higher values allow bootstrapping nodes with slower connections (300s between messages = 600 slots to keep)
    final_history_length = 600
    # path of the initial deferred credits file
    initial_deferred_credits_path = "base_config/deferred_credits.json"
    # Interval of periods between creation of each ledger backup
    ledger_backup_periods_interval = 100
    # Maximum number of ledger backup saved
    max_ledger_backups = 100

[consensus]
    # max number of previously discarded blocks kept in RAM
    max_discarded_blocks = 100
    # max number of blocks in the future kept in RAM
    max_future_processing_blocks = 400
    # max number of blocks waiting for dependencies
    max_dependency_blocks = 2048
    # number of final periods that must be kept without operations (increase improve bootstrap process, high values will increase RAM usage.)
    force_keep_final_periods_without_ops = 32
    # number of final periods that must be kept with operations (increase to more resilience to short network disconnections, high values will increase RAM usage.)
    force_keep_final_periods = 5
    # useless blocks are pruned every block_db_prune_interval ms
    block_db_prune_interval = 5000
    # considered timespan for stats info
    stats_timespan = 60000
    # blocks headers channel capacity
    broadcast_blocks_headers_channel_capacity = 128
    # blocks channel capacity
    broadcast_blocks_channel_capacity = 128
    # filled blocks channel capacity
    broadcast_filled_blocks_channel_capacity = 128

[protocol]
    # port on which to listen for protocol communication. You may need to change this to "0.0.0.0:port" if IPv6 is disabled system-wide.
    bind = "[::]:31244"
    # timeout for connection establishment
    connect_timeout = 3000
    # path to the node key (not the staking key)
    keypair_file = "config/node_privkey.key"
    # path to the initial peers file
    initial_peers_file = "base_config/initial_peers.json"
    # Limit of read/write number of bytes per second with a peer (Should be a 10 multiple)
    read_write_limit_bytes_per_second = 2_000_000_000
    # timeout after which without answer a handshake is ended
    message_timeout = 5000
    # timeout after which a peer tester will consider the peer unreachable
    tester_timeout = 10000
    # timeout after which we consider a node does not have the block we asked for
    ask_block_timeout = 10000
    # Max known blocks we keep during their propagation
    max_blocks_kept_for_propagation = 300
    # Time during which a block is expected to propagate (in milliseconds)
    max_block_propagation_time = 40000
    # Block propagation tick interval, useful for propagating blocks quickly to newly connected peers (in milliseconds)
    block_propagation_tick = 1000
    # max cache size for which blocks our node knows about
    max_known_blocks_size = 1024
    # max cache size for which blocks a foreign node knows about
    max_node_known_blocks_size = 1024
    # max cache size for which blocks a foreign node asked for
    max_node_wanted_blocks_size = 1024
    # max number of blocks we can ask simultaneously per node
    max_simultaneous_ask_blocks_per_node = 128
    # max milliseconds to wait while sending an event before dropping it
    max_send_wait = 0
    # max cache size for which operations your node knows about
    max_known_ops_size = 1000000
    # max size of the cache of asked operations
    asked_operations_buffer_capacity = 600000
    # max cache size for which operations a foreign node knows about
    max_node_known_ops_size = 200000
    # max cache size for which endorsements our node knows about
    max_known_endorsements_size = 2048
    # max cache size for which endorsements a foreign node knows about
    max_node_known_endorsements_size = 2048
    # maximum number of batches in the memory buffer.
    # dismiss the new batches if overflow
    operation_batch_buffer_capacity = 10024
    # immediately announce ops if overflow
    operation_announcement_buffer_capacity = 2000
    # start processing batches in the buffer each `operation_batch_proc_period` in millisecond
    operation_batch_proc_period = 500
    # interval at which operations are announced in batches.
    operation_announcement_interval = 300
    # max number of operation per message, same as network param but can be smaller
    max_operations_per_message = 5000
    # Number of millis seconds between each try out connections
    try_connection_timer = 250
    # Number of millis seconds between each try out connections for same peer
    try_connection_timer_same_peer = 10000
    # Number of millis seconds between each unban of every peer
    unban_everyone_timer = 86400000
    # Number of millis seconds that create a timeout for out connections
    timeout_connection = 1000
    # max number of operations kept for propagation
    max_ops_kept_for_propagation = 320000
    # time threshold after which operation are not propagated
    max_operations_propagation_time = 32000
    # time threshold after which endorsement are not propagated
    max_endorsements_propagation_time = 32000
    # number of thread tester
    thread_tester_count = 25
    # Nb max in connections that we accept
    max_in_connections = 250
    # Cooldown before testing again old peer
    test_oldest_peer_cooldown = 720000
    # Rate limitation on the data streams (per second)
    rate_limit = 5_242_880    # 5 MiB / secs
    # Peer default category limits
    default_category_info = { target_out_connections = 10, max_in_connections_per_ip = 2, max_in_connections = 15, allow_local_peers = false }
    # Peer categories limits
    [protocol.peers_categories]
    Bootstrap = { target_out_connections = 1, max_in_connections_per_ip = 1, max_in_connections = 1, allow_local_peers = false }

[network]

[metrics]
    # enable prometheus metrics
    enabled = true
    # port on which to listen for prometheus metrics
    bind = "[::]:31248"
    # interval at which to update metrics
    tick_delay = 5000

[bootstrap]
    # list of bootstrap (ip, node id)
    bootstrap_list = [
        ["149.202.86.103:31245", "N16noomm9akwBSTkvhs4KX6kjbhVhYkLqrzneCwBdo2SUE8axHx"],
        ["149.202.89.125:31245", "N12bYghvuhCuQ38iSAGQvKTb1iXtwzPZhNJLhWQPYcmgz8PDPAGo"],
        ["158.69.120.215:31245", "N1jRVjMZK8ZEmUGxDbLgHv3BTeQy8wHnazKCdcpQy4sFxu9d8GW"],
        ["158.69.23.120:31245", "N12B7LqdyVVBXr8TMygU28R7JYxUR2dsLLp63YXtH9XAR1R2NUrY"],
        ["198.27.74.5:31245", "N1FoYxXoSC39ZamAvwi7srz3oRrJ8JC3EvRhcqXPCD7vaQZTHKV"],
        ["51.75.60.228:31245", "N1nRDdGq7DFD7AvSz5pgAsXCvkcqoL5Xf3kHr8Yd3TTUgtBcBun"],
        ["[2001:41d0:1004:67::]:31245", "N16noomm9akwBSTkvhs4KX6kjbhVhYkLqrzneCwBdo2SUE8axHx"],
        ["[2001:41d0:a:7f7d::]:31245", "N12bYghvuhCuQ38iSAGQvKTb1iXtwzPZhNJLhWQPYcmgz8PDPAGo"],
        ["[2001:41d0:602:21e4::]:31245", "N1nRDdGq7DFD7AvSz5pgAsXCvkcqoL5Xf3kHr8Yd3TTUgtBcBun"],
    ]
    # force the bootstrap protocol to use: "IPv4", "IPv6", or "Both". Defaults to using both protocols.
    bootstrap_protocol = "Both"
    # path to the bootstrap whitelist file. This whitelist define IPs that can bootstrap on your node.
    bootstrap_whitelist_path = "base_config/bootstrap_whitelist.json"
    # path to the bootstrap blacklist file. This whitelist define IPs that will not be able to bootstrap on your node. This list is optional.
    bootstrap_blacklist_path = "base_config/bootstrap_blacklist.json"
    # [optional] port on which to listen for incoming bootstrap requests. You may need to change this to "0.0.0.0:port" if IPv6 is disabled system-wide.
    bind = "[::]:31245"
    # timeout to establish a bootstrap connection
    connect_timeout = 15000
    # timeout for providing the bootstrap to a connection
    bootstrap_timeout = 1200000 # 20 mins
    # delay in milliseconds to wait between consecutive bootstrap attempts
    retry_delay = 60000
    # if ping is too high bootstrap will be interrupted after max_ping milliseconds
    max_ping = 10000
    # timeout for incoming message readout
    read_timeout = 300000
    # timeout for message sending
    write_timeout = 300000
    # timeout for incoming error message readout
    read_error_timeout = 200
    # timeout for message error sending
    write_error_timeout = 200
    # max allowed difference between client and servers clocks in ms
    max_clock_delta = 5000
    # [server] data is cached for cache duration milliseconds
    cache_duration = 15000
    # max number of simultaneous bootstraps for server
    max_simultaneous_bootstraps = 2
    # max size of recently bootstrapped IP cache
    ip_list_max_size = 10000
    # refuse consecutive bootstrap attempts from a given IP when the interval between them is lower than per_ip_min_interval milliseconds
    per_ip_min_interval = 180000
    # read-write limitation for a connection in bytes per seconds (about the bootstrap specifically)
    rate_limit = 20_971_520    # 20 MiB /sec

[pool]
    # max number of operations kept in the pool
    max_operation_pool_size = 500000
    # max excess number of operations kept in pool in-between refreshes
    max_operation_pool_excess_items = 100000
    # refresh interval of the operation pool scoring (milliseconds)
    operation_pool_refresh_interval = 5000
    # if an operation is too much in the future it will be ignored (milliseconds)
    operation_max_future_start_delay = 50000
    # max number of endorsements kept per thread
    max_endorsements_pool_size_per_thread = 25000
    # max number of items returned per query
    max_item_return_count = 100
    # endorsements channel capacity
    broadcast_endorsements_channel_capacity = 2000
    # operations channel capacity
    broadcast_operations_channel_capacity = 5000
    # minimal fee to include operation in the pool 0.01MAS
    minimal_fees = 0.01


[selector]
    # path to the initial roll distribution
    initial_rolls_path = "base_config/initial_rolls.json"

[factory]
    # initial delay in milliseconds to wait before starting production to avoid double staking on node restart
    initial_delay = 100
    # path to your staking wallets
    staking_wallet_path = "config/staking_wallets"
    # stop or not the production in case we are not connected to anyone
    stop_production_when_zero_connections = true

[versioning]
    # Warn user to update its node if we reach this percentage for announced network versions
    mip_stats_warn_announced_version = 30

# Dump final blocks (in grpc binary format) by activating the feature: --features dump-block
[block_dump]
    block_dump_folder_path = "dump/blocks"
    # max number of blocks to keep in the dump folder
    max_blocks = 2048000
