Bitguus Daemon Configuration Settings

The following options are available to configure the Bitguus node daemon. These settings control various aspects of the daemon’s operation, from logging to synchronization behavior.

Running the Daemon

`--detach`

Run the daemon in the background as a detached process. This allows the node to continue running without keeping the terminal session open.

`--pidfile <arg>`

Specify the file path where the daemon’s Process ID (PID) will be written. This file can be useful for tracking or managing the process.

Note: This option is only functional when used with --detach.

`--non-interactive`

Run the daemon in a non-interactive mode, meaning no prompts or input will be requested from the user during operation.

Logging Configuration

`--log-file <arg>`

Specify the path to the log file where logs will be saved. Default log file locations: - Main network: /home/user/.bitguus/bitguus.log - Testnet: /home/user/.bitguus/testnet/bitguus.log - Stagenet: /home/user/.bitguus/stagenet/bitguus.log

`--log-level <arg>`

Set the logging level to control the verbosity of the log output. Possible levels are typically debug, info, warn, and error.

`--max-log-file-size <arg>`

Specify the maximum size of the log file in bytes. Once this size is reached, the log file will be rotated. Default is 104850000 bytes (around 100MB).

`--max-log-files <arg>`

Set the maximum number of rotated log files to keep. If set to 0, no limit is enforced, and logs are never deleted.

Performance & Resource Control

`--max-concurrency <arg>`

Define the maximum number of threads that the daemon can use for parallel processing tasks. Set this to 0 for the default (auto-determined) number of threads.

`--zmq-rpc-bind-ip <arg>`

Set the IP address for the ZMQ (ZeroMQ) RPC server to listen on. The default is 127.0.0.1 (localhost).

`--zmq-rpc-bind-port <arg>`

Specify the port on which the ZMQ RPC server will listen. Default values: - Mainnet: 29999 - Testnet: 38158 - Stagenet: 38155

Data Directory Configuration

`--data-dir <arg>`

Define the directory where the node will store its data. Default directories are: - Mainnet: /home/user/.bitguus - Testnet: /home/user/.bitguus/testnet - Stagenet: /home/user/.bitguus/stagenet

Testing and Debugging Options

`--test-drop-download`

For testing purposes, this option discards all downloaded blocks rather than saving them. This can speed up testing but should only be used in specific test environments.

`--test-drop-download-height <arg>`

Similar to --test-drop-download, but only discards blocks after reaching a specified height. This allows for more targeted testing.

`--testnet`

Run the node on the testnet environment. This mode is useful for testing without interacting with the main blockchain. The wallet must be launched with the --testnet flag.

`--stagenet`

Run the node on the stagenet (staging network). Similar to testnet but with a different set of configurations, often used for staging live environments. The wallet must be launched with the --stagenet flag.

`--regtest`

Run in regression test mode, where the node can be configured for testing specific conditions with fixed parameters.

`--fixed-difficulty <arg>`

Set a fixed difficulty level for testing purposes, overriding the normal difficulty adjustment process.

`--enforce-dns-checkpointing`

Ensure that checkpoints received from DNS servers are enforced during synchronization. This can help ensure the node stays in sync with known good blockchains.

Synchronization and Performance Tuning

`--prep-blocks-threads <arg>`

Set the maximum number of threads to use when preparing block hashes in groups for faster processing.

`--fast-block-sync <arg>`

Enable faster block synchronization by utilizing embedded, known block hashes for initial sync. Set to 1 to enable (default), or 0 to disable.

`--show-time-stats <arg>`

Show time statistics for processing blocks, transactions, and disk synchronization. This can help with debugging and performance tuning.

`--block-sync-size <arg>`

Set the number of blocks to sync at once during chain synchronization. Set to 0 for adaptive synchronization, or specify a fixed number of blocks.

Additional Daemon Configuration Settings

Version Updates

`--check-updates <arg>`

Check for new versions of the Guus software. Possible options: - disabled: No automatic updates checking. - notify: Notify when a new version is available. - download: Download the new version when available. - update: Automatically update to the new version.

Block Relay Options

`--fluffy-blocks`

Relay blocks as "fluffy blocks" (this is now the default behavior and the option is considered obsolete).

`--no-fluffy-blocks`

Relay blocks as normal, non-fluffy blocks. This option disables the "fluffy" block relay mechanism.

Debugging and Offline Operation

`--test-dbg-lock-sleep <arg>`

Define the sleep time (in milliseconds) to help debug locking behavior before and after mutex locking. A value between 100 and 1000 is useful for debugging in test environments. Default is 0, meaning no sleep.

`--offline`

Run the node in offline mode. This prevents the node from connecting to peers or listening for incoming connections.

`--disable-dns-checkpoints`

Disable the retrieval of checkpoints from DNS. This can be useful if DNS checkpoints are unreliable or if you prefer using another method for blockchain validation.

Blockchain Download and Transaction Pool

`--block-download-max-size <arg>`

Set the maximum size of the block download queue in bytes. If set to 0, the default size will be used.

`--max-txpool-weight <arg>`

Set the maximum allowed size of the transaction pool in bytes. Default is 648000000 bytes (around 648MB). This limits the size of the transaction pool to prevent excessive memory usage.

Frame Node and Transaction Privacy

`--frame`

Run the node as a frame node. This configuration may be used for specific applications that require a different network node behavior.

`--pad-transactions`

Pad relayed transactions to obscure their size and prevent traffic analysis from identifying transaction patterns.

Notifications and External Scripts

`--block-notify <arg>`

Run an external program each time a new block is added. The program will receive the block hash as an argument (e.g., %s will be replaced by the actual block hash).

`--prune-blockchain`

Enable pruning of the blockchain. This can help reduce disk usage by removing older blocks from the blockchain database.

`--reorg-notify <arg>`

Run a program when a blockchain reorganization occurs. The program will receive the following arguments: - %s: Split height - %h: New blockchain height - %n: Number of new blocks in the new chain

`--block-rate-notify <arg>`

Run a program when there are significant fluctuations in the block rate, which may indicate hash rate changes or network instability. The program will receive the following arguments: - %t: Number of minutes for the observation window - %b: Number of blocks observed within that window - %e: Number of blocks expected within that window

This can be used for automatic adjustments in confirmation requirements for payments.

Mining Configuration

`--extra-messages-file <arg>`

Specify a file that contains extra messages to be included in the coinbase transactions. This is useful for adding custom data to each block.

`--start-mining <arg>`

Specify the wallet address to start mining for. This option initiates mining for the specified address.

`--mining-threads <arg>`

Specify the number of threads to use for mining. This controls how many threads are allocated for the mining process.

`--bg-mining-enable`

Enable or disable background mining. When enabled, mining will continue even when the node is not actively being used.

`--bg-mining-ignore-battery`

If set to true, the node will assume it is plugged in for background mining even if the system cannot detect its battery status.

`--bg-mining-min-idle-interval <arg>`

Set the minimum interval (in seconds) to look back for determining idle state for background mining.

`--bg-mining-idle-threshold <arg>`

Specify the minimum average idle percentage required over the lookback interval to trigger background mining.

`--bg-mining-miner-target <arg>`

Specify the maximum percentage of CPU usage that should be used by the miner(s) when background mining is enabled.

Database Configuration

`--db-type <arg>`

Specify the type of database to use for storing blockchain data. Currently, lmdb is the supported option.

`--db-sync-mode <arg>`

Configure the synchronization mode for the database. Options include: - safe: Sync after each block. - fast: Sync asynchronously with fewer blocks. - fastest: Sync the database with minimal checks (faster but potentially riskier).

Specify additional parameters such as the number of blocks per sync or bytes per sync.

`--db-salvage`

Attempt to salvage a potentially corrupted blockchain database.

Peer-to-Peer Network Settings

`--p2p-bind-ip <arg>`

Define the local interface (IP address) to use for the peer-to-peer (P2P) network protocol (IPv4). Default is 0.0.0.0, which binds to all available interfaces.

`--p2p-bind-ipv6-address <arg>`

Define the local interface (IPv6 address) for the P2P network. Default is :: (any available IPv6 interface).

`--p2p-bind-port <arg>`

Set the port to be used for the P2P network (IPv4). Default is 27777, with different default ports for testnet (38156) and stagenet (38153).

`--p2p-bind-port-ipv6 <arg>`

Set the port to be used for the P2P network (IPv6). Default is the same as the IPv4 port unless specifically configured.

`--p2p-use-ipv6`

Enable IPv6 support for the P2P network.

`--p2p-external-port <arg>`

Specify the external port for the P2P network, useful if using NAT or port forwarding.

`--allow-local-ip`

Allow the addition of local IP addresses to the peer list. This option is mostly useful for debugging.

`--add-peer <arg>`

Manually add a peer to the local peer list. This can be used to connect to specific peers directly.

`--add-priority-node <arg>`

Specify a list of priority peers to keep connected. These peers will be prioritized for maintaining an active connection.

`--add-exclusive-node <arg>`

Specify a list of exclusive peers to connect to. If this option is enabled, the node will only connect to the peers listed here, ignoring other options like add-priority-node and seed-node.

Peer and Network Settings

Peer Connections

`--seed-node <arg>`

Connect to a specified node to retrieve peer addresses and then disconnect. This is useful for quickly discovering peers without maintaining a long-term connection.

`--hide-my-port`

Prevent your node from announcing itself as a peer candidate in the network. This makes your node less discoverable and is useful for privacy or when you're only interested in receiving connections.

`--no-igd`

Disable UPnP (Universal Plug and Play) port mapping. If disabled, the node will not automatically configure your router for port forwarding, which can affect connectivity with other peers.

`--out-peers <arg>`

Set the maximum number of outbound peers your node will attempt to connect to. If set to -1, there is no limit on the number of outgoing connections.

`--in-peers <arg>`

Set the maximum number of inbound peers your node will accept connections from. Setting this to -1 means no limit on incoming connections.

`--tos-flag <arg>`

Set the Type of Service (TOS) flag for networking. A value of -1 means it is not set. This is used for advanced network configuration.

Rate Limiting

`--limit-rate-up <arg>`

Set the upload rate limit in kilobytes per second (kB/s). The default is 2048 kB/s. This helps control how much bandwidth the node uses when sending data.

`--limit-rate-down <arg>`

Set the download rate limit in kilobytes per second (kB/s). The default is 8192 kB/s. This controls the amount of data the node can receive from peers.

`--limit-rate <arg>`

Set an overall rate limit for both upload and download in kilobytes per second. If set, this will override the individual limit-rate-up and limit-rate-down settings.

Blockchain Synchronization

`--save-graph`

Save data for Dr. Monero, which can be used for analysis or monitoring the health and status of the blockchain.

RPC Server Configuration

`--rpc-bind-port <arg>`

Set the port on which the RPC server will listen. The default port is 28888 for the mainnet. For testnet, the default is 38157, and for stagenet, it's 38154.

`--rpc-restricted-bind-port <arg>`

Set the port for the restricted RPC server, which only allows view-only commands and does not expose sensitive data.

`--restricted-rpc`

Enable the restricted RPC mode, which limits the RPC server to view-only commands. This ensures that privacy-sensitive data is not returned in RPC calls.

`--bootstrap-daemon-address <arg>`

Specify the URL of a "bootstrap" remote daemon that wallets can use while your daemon is still syncing. This allows wallets to connect to a fully-synced daemon until your node is up-to-date.

`--bootstrap-daemon-login <arg>`

Provide the username and password required to authenticate with the bootstrap daemon. Format: username:password.

RPC Server IP and Access Control

`--rpc-bind-ip <arg>`

Specify the IPv4 address to which the RPC server will bind. The default address is 127.0.0.1 (localhost), meaning the server will only be accessible from the local machine.

`--rpc-bind-ipv6-address <arg>`

Specify the IPv6 address to bind the RPC server to. By default, this is set to ::1 (localhost for IPv6).

`--rpc-use-ipv6`

Enable IPv6 support for the RPC server. If this flag is set, the RPC server will listen for IPv6 connections in addition to or instead of IPv4.

`--rpc-login <arg>`

Specify the username and optional password required for RPC server authentication. Format: username[:password].

`--confirm-external-bind`

Confirm that the rpc-bind-ip value is not a local (loopback) IP address. This option ensures that the RPC server is accessible from external sources, which can be useful for remote access or exposing the server to a wider network.

`--rpc-access-control-origins <arg>`

Specify a comma-separated list of origins allowed to access the RPC server. This is used to enable Cross-Origin Resource Sharing (CORS), which allows web clients from specified domains to make requests to the RPC server.

Conclusion

These configuration options allow for fine-tuning the Bitguus daemon’s behavior based on the network environment, system resources, and desired logging or synchronization preferences. For optimal performance, adjust settings like concurrency, log size, and block synchronization based on your system's capabilities and the current network conditions.