min_mainnet_k_size: 32

# Send a ping to all peers after ping_interval seconds
ping_interval: 120
self_hostname: &self_hostname "localhost"
prefer_ipv6: False
rpc_timeout: 300
daemon_port: 55400
daemon_max_message_size: 50000000 # maximum size of RPC message in bytes
daemon_heartbeat: 300 # sets the heartbeat for ping/ping interval and timeouts
daemon_allow_tls_1_2: False # if True, allow TLS 1.2 for daemon connections
inbound_rate_limit_percent: 100
outbound_rate_limit_percent: 30

network_overrides: &network_overrides
  constants:
    mainnet:
      GENESIS_CHALLENGE: ccd5bb71183532bff220ba46c268991a3ff07eb358e8255a65c30a2dce0e5fbb
      GENESIS_PRE_FARM_POOL_PUZZLE_HASH: "d23da14695a188ae5708dd152263c4db883eb27edeb936178d4d988b8f3ce5fc"
      GENESIS_PRE_FARM_FARMER_PUZZLE_HASH: "3d8765d3a597ec1d99663f6c9816d915b9f68613ac94009884c4addaefcce6af"
    testnet0:
      MIN_PLOT_SIZE: 18
      GENESIS_CHALLENGE: e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
      GENESIS_PRE_FARM_POOL_PUZZLE_HASH: "d23da14695a188ae5708dd152263c4db883eb27edeb936178d4d988b8f3ce5fc"
      GENESIS_PRE_FARM_FARMER_PUZZLE_HASH: "3d8765d3a597ec1d99663f6c9816d915b9f68613ac94009884c4addaefcce6af"
    testnet11:
      AGG_SIG_ME_ADDITIONAL_DATA: 37a90eb5185a9c4439a91ddc98bbadce7b4feba060d50116a067de66bf236615
      DIFFICULTY_CONSTANT_FACTOR: 10052721566054
      DIFFICULTY_STARTING: 30
      EPOCH_BLOCKS: 768
      GENESIS_CHALLENGE: 37a90eb5185a9c4439a91ddc98bbadce7b4feba060d50116a067de66bf236615
      GENESIS_PRE_FARM_FARMER_PUZZLE_HASH: 08296fc227decd043aee855741444538e4cc9a31772c4d1a9e6242d1e777e42a
      GENESIS_PRE_FARM_POOL_PUZZLE_HASH: 3ef7c233fc0785f3c0cae5992c1d35e7c955ca37a423571c1607ba392a9d12f7
      MEMPOOL_BLOCK_BUFFER: 10
      MIN_PLOT_SIZE: 18
      NETWORK_TYPE: 1
      SUB_SLOT_ITERS_STARTING: 67108864
      # Forks activated from the beginning on this network
      HARD_FORK_HEIGHT: 0
      SOFT_FORK4_HEIGHT: 641500
      SOFT_FORK5_HEIGHT: 1340000
      PLOT_FILTER_128_HEIGHT: 6029568
      PLOT_FILTER_64_HEIGHT: 11075328
      PLOT_FILTER_32_HEIGHT: 16121088
    testneta:
      AGG_SIG_ME_ADDITIONAL_DATA: b0a306abe27407130586c8e13d06dc057d4538c201dbd36c8f8c481f5e51af5c
      DIFFICULTY_CONSTANT_FACTOR: 10052721566054
      DIFFICULTY_STARTING: 30
      EPOCH_BLOCKS: 768
      GENESIS_CHALLENGE: b0a306abe27407130586c8e13d06dc057d4538c201dbd36c8f8c481f5e51af5c
      GENESIS_PRE_FARM_FARMER_PUZZLE_HASH: 08296fc227decd043aee855741444538e4cc9a31772c4d1a9e6242d1e777e42a
      GENESIS_PRE_FARM_POOL_PUZZLE_HASH: 08296fc227decd043aee855741444538e4cc9a31772c4d1a9e6242d1e777e42a
      MEMPOOL_BLOCK_BUFFER: 10
      MIN_PLOT_SIZE: 18
      NETWORK_TYPE: 1
      SUB_SLOT_ITERS_STARTING: 67108864
  config:
    mainnet:
      address_prefix: "xch"
      default_full_node_port: 8444
    testnet0:
      address_prefix: "txch"
      default_full_node_port: 58444
    testnet11:
      address_prefix: "txch"
      default_full_node_port: 58444
    testneta:
      address_prefix: "txch"
      default_full_node_port: 58444

selected_network: &selected_network "mainnet"

# public ssl ca is included in source code
# Private ssl ca is used for trusted connections between machines user owns
private_ssl_ca:
  crt: "config/ssl/ca/private_ca.crt"
  key: "config/ssl/ca/private_ca.key"

chia_ssl_ca:
  crt: "config/ssl/ca/chia_ca.crt"
  key: "config/ssl/ca/chia_ca.key"

daemon_ssl:
  private_crt: "config/ssl/daemon/private_daemon.crt"
  private_key: "config/ssl/daemon/private_daemon.key"

# Controls logging of all servers (harvester, farmer, etc..). Each one can be overridden.
logging: &logging
  log_stdout: False # If True, outputs to stdout instead of a file
  log_filename: "log/debug.log"
  log_level: "WARNING" # Can be CRITICAL, ERROR, WARNING, INFO, DEBUG, NOTSET
  log_maxfilesrotation: 7 #  Max files in rotation. Default value 7 if the key is not set
  log_maxbytesrotation: 52428800 #  Max bytes logged before rotating logs
  log_use_gzip: False #  Use gzip to compress rotated logs
  log_syslog: False # If True, outputs to SysLog host and port specified
  log_syslog_host: "localhost" # Send logging messages to a remote or local Unix syslog
  log_syslog_port: 514 # UDP port of the remote or local Unix syslog

seeder:
  # The fake full node used for crawling will run on this port.
  port: 8444
  # Most full nodes on the network run on this port. (i.e. 8444 for mainnet, 58444 for testnet).
  other_peers_port: 8444
  # What port to run the DNS server on, (this is useful if you are already using port 53 for DNS).
  dns_port: 53
  # This will override the default full_node.peer_connect_timeout for the crawler full node
  peer_connect_timeout: 2
  # Path to crawler DB. Defaults to $CHIA_ROOT/crawler.db
  crawler_db_path: "crawler.db"
  # Peers used for the initial run.
  bootstrap_peers:
    - "node.chia.net"
  # Only consider nodes synced at least to this height.
  minimum_height: 240000
  # How many of a particular version we need to see before reporting it in the logs
  minimum_version_count: 100
  domain_name: "seeder.example.com."
  nameserver: "example.com."
  ttl: 300
  soa:
    rname: "hostmaster.example.com" # all @ symbols need to be replaced with . in dns records.
    serial_number: 1619105223
    refresh: 10800
    retry: 10800
    expire: 604800
    minimum: 1800
  network_overrides: *network_overrides
  selected_network: *selected_network
  logging: *logging
  # Crawler is its own standalone service within the seeder component
  crawler:
    start_rpc_server: True
    rpc_port: 8561
    prune_peer_days: 90 # Peers older than this many days will be removed from the crawler database
    ssl:
      private_crt: "config/ssl/crawler/private_crawler.crt"
      private_key: "config/ssl/crawler/private_crawler.key"

harvester:
  farmer_peers:
    - host: *self_hostname
      port: 8447

  # If True, starts an RPC server at the following port
  start_rpc_server: True
  rpc_port: 8560
  num_threads: 30
  plots_refresh_parameter:
    interval_seconds: 120 # The interval in seconds to refresh the plot file manager
    retry_invalid_seconds: 1200 # How long to wait before re-trying plots which failed to load
    batch_size: 300 # How many plot files the harvester processes before it waits batch_sleep_milliseconds
    batch_sleep_milliseconds: 1 # Milliseconds the harvester sleeps between batch processing

  # If True use parallel reads in chiapos
  parallel_read: True

  logging: *logging
  network_overrides: *network_overrides
  selected_network: *selected_network

  # Plots are searched for in the following directories
  plot_directories: []
  recursive_plot_scan: False # If True the harvester scans plots recursively in the provided directories.

  ssl:
    private_crt: "config/ssl/harvester/private_harvester.crt"
    private_key: "config/ssl/harvester/private_harvester.key"

  private_ssl_ca:
    crt: "config/ssl/ca/private_ca.crt"
    key: "config/ssl/ca/private_ca.key"

  chia_ssl_ca:
    crt: "config/ssl/ca/chia_ca.crt"
    key: "config/ssl/ca/chia_ca.key"

  # Compressed harvesting.
  parallel_decompressor_count: 0
  # If set to 0, `decompressor_thread_count` will default to half of nproc available on the machine.
  # A non-zero number overrides this default.
  decompressor_thread_count: 0
  disable_cpu_affinity: False
  # Ignore compressed plots with compression level greater than this.
  max_compression_level_allowed: 7
  use_gpu_harvesting: False
  gpu_index: 0
  enforce_gpu_index: False
  # If no decompressor is available after `decompressor_timeout` seconds, abort the current operation.
  decompressor_timeout: 20

pool:
  # Replace this with a real receive address
  # xch_target_address: txch102gkhhzs60grx7cfnpng5n6rjecr89r86l5s8xux2za8k820cxsq64ssdg
  logging: *logging
  network_overrides: *network_overrides
  selected_network: *selected_network

farmer:
  # The farmer server (if run) will run on this port
  port: 8447
  # The farmer will attempt to connect to these full nodes
  full_node_peers:
    - host: *self_hostname
      port: 8444

  pool_public_keys: !!set {}

  # Replace this with a real receive address
  # xch_target_address: txch102gkhhzs60grx7cfnpng5n6rjecr89r86l5s8xux2za8k820cxsq64ssdg

  # If True, starts an RPC server at the following port
  start_rpc_server: True
  rpc_port: 8559

  # when enabled, the farmer will print a pstats profile to the
  # root_dir/profile-farmer directory every second.
  # analyze with python -m chia.util.profiler <path>
  enable_profiler: False

  # To send a share to a pool, a proof of space must have required_iters less than this number
  pool_share_threshold: 1000
  logging: *logging
  network_overrides: *network_overrides
  selected_network: *selected_network

  ssl:
    private_crt: "config/ssl/farmer/private_farmer.crt"
    private_key: "config/ssl/farmer/private_farmer.key"
    public_crt: "config/ssl/farmer/public_farmer.crt"
    public_key: "config/ssl/farmer/public_farmer.key"

# Don't run this unless you want to run VDF clients on the local machine.
timelord_launcher:
  # The server where the VDF clients will connect to.
  host: *self_hostname
  port: 8000
  # Number of VDF client processes to keep alive in the local machine.
  process_count: 3
  logging: *logging

timelord:
  # Provides a list of VDF clients expected to connect to this timelord.
  # For each client, an IP is provided, together with the estimated iterations per second.
  vdf_clients:
    ip:
      - *self_hostname
      - localhost
      - 127.0.0.1
    ips_estimate:
      - 150000
  full_node_peers:
    - host: *self_hostname
      port: 8444
  # Maximum number of seconds allowed for a client to reconnect to the server.
  max_connection_time: 60
  # The ip and port where the TCP clients will connect.
  vdf_server:
    host: *self_hostname
    port: 8000
  logging: *logging
  network_overrides: *network_overrides
  selected_network: *selected_network
  # fast_algorithm is a faster proof generation algorithm. This speed increase
  # requires much less memory usage and a does not have the risk of OOM that
  # the normal timelord has but requires significantly more cores doing
  # parallel proof generation and creates a larger and slower to verify
  # resulting proof.
  # An Intel Core i9-10900K can run 2 normal vdf_clients at ~221,000 ips
  # without slowing down but running more than 1 with fast_algorithm will
  # run each vdf_client slower.
  fast_algorithm: False
  # Bluebox (sanitizing timelord):
  # If set 'True', the timelord will create compact proofs of time, instead of
  # extending the chain. The attribute 'fast_algorithm' won't apply if timelord
  # is running in bluebox_mode.
  # You must set 'send_uncompact_interval' in 'full_node' > 0 in the full_node
  # section below to have full_node send existing time proofs to be sanitized.
  bluebox_mode: False
  # This runs a less CPU intensive bluebox. Runs for windows. Settings apply as for `bluebox_mode`.
  # Optionally set `process_count` in `timelord_launcher` to 0, since timelord launcher won't be used in this case.
  # IMPORTANT! `bluebox_mode` must also be set to True for this option to work.
  slow_bluebox: False
  # If `slow_bluebox` is True, launches `slow_bluebox_process_count` processes.
  slow_bluebox_process_count: 1

  multiprocessing_start_method: default

  start_rpc_server: True
  rpc_port: 8557

  ssl:
    private_crt: "config/ssl/timelord/private_timelord.crt"
    private_key: "config/ssl/timelord/private_timelord.key"
    public_crt: "config/ssl/timelord/public_timelord.crt"
    public_key: "config/ssl/timelord/public_timelord.key"

full_node:
  # The full node server (if run) will run on this port
  port: 8444
  # The full node will attempt to connect to these full nodes
  full_node_peers: []

  # controls the sync-to-disk behavior of the database connection. Can be one of:
  # "on"    enables syncing to disk, minimizes risk of corrupting the DB in
  #         power-loss, disk failure or kernel panics
  # "full"  enables extra syncing to disk for additional safety from
  #         power-failures and kernel panics
  # "off"   disables syncing, lightens disk load and improves performance.
  #         increases risk of corrupting DB in power-loss, disk failure or
  #         kernel panics
  # "auto"  on/off is decided based on a heuristic of how likely a failure is on
  #         the particular system we're running on. Defaults to "full".
  db_sync: "auto"

  # the number of threads used to read from the blockchain database
  # concurrently. There's always only 1 writer, but the number of readers is
  # configurable
  db_readers: 4

  # Run multiple nodes with different databases by changing the database_path
  database_path: db/blockchain_v2_CHALLENGE.sqlite
  # peer_db_path is deprecated and has been replaced by peers_file_path
  peer_db_path: db/peer_table_node.sqlite
  peers_file_path: db/peers.dat

  multiprocessing_start_method: default

  # The maximum number of UnfinishedBlocks we accept (and forward) with the
  # same reward hash (but different foliage hashes). Traditionally this was
  # effectively 1, meaning whichever UnfinishedBlock we saw first was the only
  # one we forwarded. In 2.2.0 we relaxed the protocol to allow some
  # duplicates be forwarded, in order to allow the timelords to,
  # deterministically, pick which one to infuse
  max_duplicate_unfinished_blocks: 3

  # If True, starts an RPC server at the following port
  start_rpc_server: True
  rpc_port: 8555

  # Use UPnP to attempt to allow other full nodes to reach your node behind a gateway
  enable_upnp: True

  # If node is more than these blocks behind, will do a sync (long sync)
  sync_blocks_behind_threshold: 300

  # If node is more than these blocks behind, will do a short batch-sync, if it's less, will do a backtrack sync
  short_sync_blocks_behind_threshold: 20

  bad_peak_cache_size: 100

  # When creating process pools the process count will generally be the CPU count minus
  # this reserved core count.
  reserved_cores: 0

  # set this to true to not offload heavy lifting into separate child processes.
  # this option is mostly useful when profiling, since only the main process is
  # profiled.
  single_threaded: False

  # How often to initiate outbound connections to other full nodes.
  peer_connect_interval: 30
  # How long to wait for a peer connection
  peer_connect_timeout: 30
  # Accept peers until this number of connections
  target_peer_count: 40
  # Initiate outbound connections until this number is hit.
  target_outbound_peer_count: 8
  # IPv4/IPv6 network addresses and CIDR blocks allowed to connect even when target_peer_count has been hit.
  # exempt_peer_networks: ["192.168.0.3", "192.168.1.0/24", "fe80::/10", "2606:4700:4700::64/128"]
  exempt_peer_networks: []
  # Accept at most # of inbound connections for different node types.
  max_inbound_wallet: 20
  max_inbound_farmer: 10
  max_inbound_timelord: 5
  # Only connect to peers who we have heard about in the last recent_peer_threshold seconds
  recent_peer_threshold: 6000

  # Send to a Bluebox (sanitizing timelord) uncompact blocks once every
  # 'send_uncompact_interval' seconds. Set to 0 if you don't use this feature.
  send_uncompact_interval: 0
  # At every 'send_uncompact_interval' seconds, send blueboxes 'target_uncompact_proofs' proofs to be normalized.
  target_uncompact_proofs: 100
  # Setting this flag as True, blueboxes will sanitize only data needed in weight proof calculation, as opposed to whole blocks.
  # Default is set to False, as the network needs only one or two blueboxes like this.
  sanitize_weight_proof_only: False
  # timeout for weight proof request
  weight_proof_timeout: &weight_proof_timeout 360

  # when the full node enters sync-mode, we wait until we have collected peaks
  # from at least 3 peers, or until we've waitied this many seconds
  max_sync_wait: 30

  # when enabled, the full node will print a pstats profile to the
  # root_dir/profile-node directory every second.
  # analyze with python -m chia.util.profiler <path>
  enable_profiler: False

  # when enabled, each time a block is validated, the python profiler is
  # engaged. If the validation takes more than 2 seconds, the profile is saved
  # to disk, in the chia root/block-validation-profile
  profile_block_validation: False

  enable_memory_profiler: False

  # this is a debug and profiling facility that logs all SQLite commands to a
  # separate log file (under logging/sql.log).
  log_sqlite_cmds: False

  # Number of coin_ids | puzzle hashes that node will let wallets subscribe to
  max_subscribe_items: 200000

  # the maximum number of CoinStates will be returned by a RegisterForPhUpdates
  # request, for untrusted peers
  max_subscribe_response_items: 100000

  # Number of coin_ids | puzzle hashes that node will let local wallets subscribe to
  trusted_max_subscribe_items: 2000000

  # the maximum number of CoinStates will be returned by a RegisterForPhUpdates
  # request, for trusted peers
  trusted_max_subscribe_response_items: 500000

  # List of trusted DNS seeders to bootstrap from.
  # If you modify this, please change the hardcode as well from FullNode.set_server()
  dns_servers: &dns_servers
    - "dns-introducer.chia.net"
    - "chia.ctrlaltdel.ch"
    - "seeder.dexie.space"
    - "chia-seeder.h9.com"
    - "chia.hoffmang.com"
    - "seeder.xchpool.org"
  introducer_peer:
    host: introducer.chia.net # Chia AWS introducer IPv4/IPv6
    port: 8444
    enable_private_networks: False
  logging: *logging
  network_overrides: *network_overrides
  selected_network: *selected_network

  # Node IDs of trusted wallet peers, allows using more permissive limits on sync
  trusted_peers:
    0ThisisanexampleNodeID7ff9d60f1c3fa270c213c0ad0cb89c01274634a7c3cb7: Does_not_matter

  ssl:
    private_crt: "config/ssl/full_node/private_full_node.crt"
    private_key: "config/ssl/full_node/private_full_node.key"
    public_crt: "config/ssl/full_node/public_full_node.crt"
    public_key: "config/ssl/full_node/public_full_node.key"
  use_chia_loop_policy: True

ui:
  # Which port to use to communicate with the full node
  rpc_port: 8555

  # This SSH key is for the ui SSH server
  ssh_filename: config/ssh_host_key
  logging: *logging
  network_overrides: *network_overrides
  selected_network: *selected_network

  # this is where the electron UI will find its daemon
  # defaults to the one running locally with its private keys
  daemon_host: *self_hostname
  daemon_port: 55400
  daemon_ssl:
    private_crt: config/ssl/daemon/private_daemon.crt
    private_key: config/ssl/daemon/private_daemon.key

introducer:
  host: *self_hostname
  port: 8445
  max_peers_to_send: 20
  # The introducer will only return peers it has seen in the last
  # recent_peer_threshold seconds
  recent_peer_threshold: 6000
  logging: *logging
  network_overrides: *network_overrides
  selected_network: *selected_network

  ssl:
    public_crt: "config/ssl/full_node/public_full_node.crt"
    public_key: "config/ssl/full_node/public_full_node.key"

wallet:
  rpc_port: 9256

  # when enabled, the wallet will print a pstats profile to the
  # root_dir/profile-wallet directory every second.
  # analyze with python -m chia.util.profiler <path>
  enable_profiler: False

  enable_memory_profiler: False

  # see description for full_node.db_sync
  db_sync: auto

  # the number of threads used to read from the wallet database
  # concurrently. There's always only 1 writer, but the number of readers is
  # configurable
  db_readers: 2

  connect_to_unknown_peers: True

  initial_num_public_keys: 425
  reuse_public_key_for_change:
    #Add your wallet fingerprint here, this is an example.
    "2999502625": False

  dns_servers: *dns_servers

  full_node_peers:
    - host: *self_hostname
      port: 8444
  # The path of NFT off-chain metadata cache
  nft_metadata_cache_path: "nft_cache"
  # The length of NFT ID prefix will be used as hash index
  nft_metadata_cache_hash_length: 3
  multiprocessing_start_method: default

  testing: False
  # v2 used by the light wallet sync protocol
  database_path: wallet/db/blockchain_wallet_v2_CHALLENGE_KEY.sqlite
  # wallet_peers_path is deprecated and has been replaced by wallet_peers_file_path
  wallet_peers_path: wallet/db/wallet_peers.sqlite
  wallet_peers_file_path: wallet/db/wallet_peers.dat

  # this is a debug and profiling facility that logs all SQLite commands to a
  # separate log file (under logging/wallet_sql.log).
  log_sqlite_cmds: False

  logging: *logging
  network_overrides: *network_overrides
  selected_network: *selected_network

  target_peer_count: 3
  peer_connect_interval: 60
  # The introducer will only return peers who it has seen in the last
  # recent_peer_threshold seconds
  recent_peer_threshold: 6000

  introducer_peer:
    host: introducer.chia.net # Chia AWS introducer IPv4/IPv6
    port: 8444
    enable_private_networks: False

  ssl:
    private_crt: "config/ssl/wallet/private_wallet.crt"
    private_key: "config/ssl/wallet/private_wallet.key"
    public_crt: "config/ssl/wallet/public_wallet.crt"
    public_key: "config/ssl/wallet/public_wallet.key"

  # Node IDs of trusted full node peers, for performing a fast trusted wallet sync
  trusted_peers:
    0ThisisanexampleNodeID7ff9d60f1c3fa270c213c0ad0cb89c01274634a7c3cb9: Does_not_matter

  short_sync_blocks_behind_threshold: 20

  # wallet overrides for limits
  inbound_rate_limit_percent: 100
  outbound_rate_limit_percent: 60

  # timeout for weight proof request
  weight_proof_timeout: *weight_proof_timeout

  # if an unknown CAT belonging to us is seen, a wallet will be automatically created
  # the user accepts the risk/responsibility of verifying the authenticity and origin of unknown CATs
  automatically_add_unknown_cats: False

  # Interval to resend unconfirmed transactions, even if previously accepted into Mempool
  tx_resend_timeout_secs: 1800

  # Reset wallet sync data on start for given fingerprint
  reset_sync_for_fingerprint: null

  # After n received unspent transactions, the spam filter will be enabled, which will filter out received
  # coins with very small value. Any standard TX under xch_spam_amount is filtered
  spam_filter_after_n_txs: 200
  xch_spam_amount: 1000000
  # Enable notifications from parties on chain
  enable_notifications: True
  # The amount someone has to pay you in mojos for you to see their notification
  required_notification_amount: 10000000

  # Enabling the delta sync can under certain circumstances lead to missing coin states during re-orgs
  use_delta_sync: False

  #################################
  #  Inner puzzle decorators      #
  #################################
  # Default puzzle decorator settings, this will apply to all asset wallets under the same key
  # Here is an example
  # puzzle_decorators:
  #   2999502625:
  #     - decorator: "CLAWBACK"
  #       clawback_timelock: 3600
  #     - decorator: "DECORATOR_TYPE" #If you want to add more decorators
  #       parameter1: 0

  auto_claim:
    enabled: False
    tx_fee: 0
    min_amount: 0
    batch_size: 50

  auto_sign_txs: True

data_layer:
  # TODO: consider name
  # TODO: organize consistently with other sections
  wallet_peer:
    host: localhost
    port: 9256

  database_path: "data_layer/db/data_layer_CHALLENGE.sqlite"
  # The location where the server files will be stored.
  server_files_location: "data_layer/db/server_files_location_CHALLENGE"
  # The timeout for the client to download a file from a server
  client_timeout: 45
  connect_timeout: 5
  # If you need use a proxy for download data you can use this setting sample
  # proxy_url: http://localhost:8888

  # Data for running a data layer server.
  host_ip: 0.0.0.0
  host_port: 8575
  # Data for running a data layer client.
  manage_data_interval: 60
  selected_network: *selected_network
  # If True, starts an RPC server at the following port
  start_rpc_server: True
  # TODO: what considerations are there in choosing this?
  rpc_port: 8562
  rpc_server_max_request_body_size: 26214400

  # this is a debug and profiling facility that logs all SQLite commands to a
  # separate log file (under logging/data_sql.log).
  log_sqlite_cmds: False

  # Speeds up autoinserts. Disable to perform inserts one by one instead of in a batch.
  enable_batch_autoinsert: True

  logging: *logging

  ssl:
    private_crt: "config/ssl/data_layer/private_data_layer.crt"
    private_key: "config/ssl/data_layer/private_data_layer.key"
    public_crt: "config/ssl/data_layer/public_data_layer.crt"
    public_key: "config/ssl/data_layer/public_data_layer.key"

  plugins:
    uploaders: []
    downloaders: []
  maximum_full_file_count: 1

simulator:
  # Should the simulator farm a block whenever a transaction is in mempool
  auto_farm: True

  # The key used by the simulator to farm blocks and send transactions
  key_fingerprint:

  # The target address for any blocks that are farmed
  farming_address:

  # the directory used to save plots
  # for the plot directory below the final directory will be: ~/.chia/simulator/plots
  plot_directory: simulator/plots

  # Should we use real time in the simulated chain?
  # most tests don't need this, however it is pretty important when writing ChiaLisp
  use_current_time: True

  # Fork Settings
  HARD_FORK_HEIGHT: 0
  SOFT_FORK4_HEIGHT: 0
  SOFT_FORK5_HEIGHT: 0
