开始使用 FearMiner 挖矿

# FearMiner configuration file (TOML), as `fearminer config example` prints it.
#
# Every option of `fearminer --help` has a key here: the option's long name
# with underscores (--temp-limit is temp_limit), at the top level or under the
# section named after its --help heading, as below. The pool list can also be
# written one table per pool:
#
#   [[pools]]
#   url = "stratum+ssl://host:port"
#   user = "WALLET.rig1"          # optional: one wallet under [pool] serves all
#   pass = "x"
#   tls_fingerprint = "SHA256"      # or tls_spki = "sha256/BASE64"
#
# Precedence, lowest first: the defaults, this file, the FEARMINER_* environment
# variables, the command line. A list (the pools, the per-pool values) is
# replaced as a whole by the source that sets it, never merged. ${VAR} in a
# string is replaced by that environment variable; one that is not set is an
# error, and so is a key that is not an option. The file is read from --config
# (FEARMINER_CONFIG), else fearminer.toml beside the binary, else the one in
# the configuration directory (~/.config/fearminer, %APPDATA%\fearminer,
# ~/Library/Application Support/fearminer). The miner never writes it.
#
# As printed, this file changes nothing: without a wallet and a pool the miner
# starts in monitoring mode. To mine, set both user (the wallet) and url (the
# pool you chose, stratum+ssl://POOL:PORT): a wallet without a pool is refused
# (E224), the miner never picks a pool for you.

[pool]

# Pool URL: stratum+tcp://host:port, stratum+ssl://host:port, or host:port
# (plain TCP unless --tls). The host is resolved on every connection. Repeat
# it (or separate the URLs with commas) for backup pools: the first is the
# primary, the others are tried in order when it fails, and the miner returns
# to the primary when it answers again
# (--url, FEARMINER_URL)
# url = []

# Wallet address, with an optional worker name as WALLET.WORKER. One value is
# used on every pool; one per pool (repeated, or comma separated, in the order
# of the pools) when a backup needs another
# (--user, FEARMINER_USER)
# user = []

# Worker name, appended to --user as WALLET.WORKER when it has none
# (--worker, FEARMINER_WORKER)
# worker = <NAME>

# Pool password. Pools ignore it; x by convention. One value for every pool,
# or one per pool like --user. A real password here is visible in the process
# list: put it in a file and use --pass-file
# (--pass, FEARMINER_PASS)
# pass = []

# Read the pool password(s) from this file instead of -p: one line for every
# pool, or one line per pool in the order of the pools. Wins over -p and
# FEARMINER_PASS when both are given. On Unix the miner warns when other users
# can read the file
# (--pass-file, FEARMINER_PASS_FILE)
# pass_file = <PATH>

# Send the wallet to the pool without checking that it is an address of the
# algorithm's chain (the banner then says UNCHECKED)
# (--ignore-wallet-check, FEARMINER_IGNORE_WALLET_CHECK)
ignore_wallet_check = false

# Use TLS on a bare host:port (a stratum+ssl:// URL implies it)
# (--tls, FEARMINER_TLS)
tls = false

# Pin the pool's TLS certificate by its SHA-256 fingerprint (64 hex digits),
# for a pool with a self-signed certificate. Without it the certificate is
# checked against the public roots. One value for every pool, or one per pool
# like --user (a dash, -, for a pool without one)
# (--tls-fingerprint, FEARMINER_TLS_FINGERPRINT)
# tls_fingerprint = []

# Pin the pool's TLS certificate by the SHA-256 of its public key (SPKI), as
# sha256/BASE64 (the HPKP notation); a pin that survives a certificate renewal
# that keeps the key. One value for every pool, or one per pool like --user (a
# dash, -, for a pool without one). Wins over --tls-fingerprint for the same
# pool
# (--tls-spki, FEARMINER_TLS_SPKI)
# tls_spki = []

# Connection attempts on a pool, on a network error, before the next pool of
# the list is tried. A pool that refuses the login is left for the next one at
# once. With every pool down the miner keeps trying them in turn, with a pause
# of up to 60 s between rounds, for ever
# (--pool-retries, FEARMINER_POOL_RETRIES)
pool_retries = 3

# Seconds without a new job from the pool, on a connection that is otherwise
# alive, before the session is treated as dead: the workers stop and the miner
# reconnects under the same rules as a lost connection. Without it, the
# algorithm's own figure, which the start says. 0 turns the guard off
# (--job-timeout, FEARMINER_JOB_TIMEOUT)
# job_timeout = <SECS>

# Seconds a submitted share waits for the pool's reply before it is counted as
# unanswered (E125); --max-no-submit-responses unanswered submits in a row
# reconnect the session
# (--submit-timeout, FEARMINER_SUBMIT_TIMEOUT)
submit_timeout = 10

# The most a pool may take to answer a submit, in milliseconds, as the median
# of the last twenty replies: over it for two minutes, the session moves to a
# pool of the list that answers faster, when one does (E129). 0 turns it off
# (--max-latency, FEARMINER_MAX_LATENCY)
max_latency = 0

# Algorithm to mine, or the coin's name (--list-algorithms for the names and
# aliases). Without it, the chain is read off the wallet; the engine index's
# default algorithm when no wallet is given
# (--algo, FEARMINER_ALGO)
# algo = <ALGO>

# List the algorithms the engine index lists (the cached or the release's
# copy), with their fee ceiling, and exit; with --json, one array of {name,
# coin, class, fee_bps, aliases, unit, hive, hive_units, default,
# requirements, options, refused}
# (--list-algorithms)
list_algorithms = false

# Hold an algorithm's engine at a version of the signed index, ALGO=VERSION
# (repeatable, or comma-separated): that version runs, from the cache or
# downloaded, and the hourly update leaves the algorithm alone
# (--engine, FEARMINER_ENGINE)
# engine = []

# An option of the algorithm's engine, NAME=VALUE (repeatable, or
# comma-separated): --list-algorithms says which an algorithm has and the
# values each takes. One the algorithm does not have, or a value it does not
# take, is refused
# (--engine-opt, FEARMINER_ENGINE_OPT)
# engine_opt = []

# The option an earlier miner had for one engine's precision: now --engine-opt
# precision=VALUE, which this still sets for an algorithm whose engine has it.
# Ignored by the others
# (--tsc-precision, FEARMINER_TSC_PRECISION)
# tsc_precision = <VALUE>

[network]

# Reach every pool through this SOCKS5 proxy (Tor: socks5://127.0.0.1:9050),
# with a username and a password as socks5://user:pass@host:port. The pool
# names are sent to the proxy, which resolves them: no DNS query leaves the
# machine for them, and a .onion pool works. A proxy that fails is a
# connection that failed; the pool is never contacted directly. socks5h:// is
# accepted and means the same
# (--proxy, FEARMINER_PROXY)
# proxy = <URL>

# How the pool names are resolved: system (the operating system's resolver),
# doh (DNS over HTTPS at --doh-url, the system resolver when the endpoint does
# not answer, never for a name it says does not exist) or doh-strict (DNS over
# HTTPS and nothing else). DoH hides the names from the local resolver, not
# the pool from the network: the TLS SNI stays visible. Moot with --proxy
# (--dns, FEARMINER_DNS)
dns = "system"

# The DNS-over-HTTPS resolver (RFC 8484) for --dns doh and doh-strict. Name it
# by its IP (https://1.1.1.1/dns-query) when the resolver's own name is what
# the local DNS cannot resolve
# (--doh-url, FEARMINER_DOH_URL)
doh_url = "https://cloudflare-dns.com/dns-query"

# The address families a pool is reached on: any (IPv6 first, IPv4 250 ms
# later, the first to connect wins), 4 or 6
# (--ip, FEARMINER_IP)
ip = "any"

# IPv4 only: the same as --ip 4
# (--ipv4-only)
ipv4_only = false

# IPv6 only: the same as --ip 6
# (--ipv6-only)
ipv6_only = false

# Trust a pool's TLS certificate on first use: remember its fingerprint at the
# first handshake (tls-pins.json in the state directory) and refuse any other
# certificate from that pool afterwards. For a node or a P2Pool on a
# self-signed certificate; a pool with --tls-fingerprint or --tls-spki is
# checked against its pin instead
# (--tls-tofu, FEARMINER_TLS_TOFU)
tls_tofu = false

# Accept whatever TLS certificate a stratum+ssl:// pool presents: no chain,
# name or expiry check. For a TLS port forward or a proxy, where the name
# dialled is not the pool's and the public roots refuse a path that works (a
# network that blocks plaintext stratum, say). The session stays encrypted,
# but anyone on the path can impersonate the pool, which every start says
# (E120). A pool with --tls-fingerprint or --tls-spki is still checked against
# its pin, and the fee sessions go the way the pools go. Refused with
# --tls-tofu, and with no stratum+ssl:// pool without a pin to apply it to
# (--tls-insecure, FEARMINER_TLS_INSECURE)
tls_insecure = false

# Forget the certificate remembered for this pool (host:port, as the E118 line
# prints it) before connecting, so the one it presents now is trusted and
# remembered instead. Repeat it for several pools
# (--tls-tofu-reset)
# tls_tofu_reset = []

# A relay of your own for the remote control, tried before the built-in one
# (wss://relay.fearminer.com): wss://HOST[:PORT], or ws:// for one on this
# machine or this network. Repeat it for several. Nothing is contacted until
# the rig is enrolled (fearminer enroll)
# (--remote-relay, FEARMINER_REMOTE_RELAY)
# remote_relay = []

# Minutes a new wallet from a cockpit's mining sheet waits before it applies,
# announced with both addresses; any cockpit or `fearminer remote cancel`
# drops it meanwhile. 0 applies at once
# (--remote-wallet-delay, FEARMINER_REMOTE_WALLET_DELAY)
remote_wallet_delay = 0

# No automatic update. A service the cockpit can update (Linux, systemd, with
# its updater) installs a newer release by itself, within two hours of seeing
# it; with this, only the cockpit's Update button or fearminer service update
# does. The cockpit can turn it back on or off for the rig
# (--no-auto-update, FEARMINER_NO_AUTO_UPDATE)
no_auto_update = false

# Join the fleet of this code at start (fm1_..., from the cockpit's Add a
# rig): the same as `fearminer enroll CODE`, for a service, a HiveOS flight
# sheet, an mmpOS miner profile or a provisioning script. Nothing happens once
# the rig is in that fleet
# (--enroll, FEARMINER_ENROLL)
# enroll = <CODE>

[devices]

# GPUs to mine on, comma separated (default: all): an index as --list-devices
# prints it (0), a PCI id (pci:0000:41:00.0, 41:00.0, or the bus alone as
# pci:41 in hex or bus:65 in decimal), a UUID as --list-devices prints it
# (GPU-3f2a..., whole), a vendor (nvidia, amd, intel: every card of it), or
# cards to leave out with a leading ! (!1, !pci:41:00.0, !GPU-3f2a...,
# !nvidia), or none for no GPU at all (the CPU threads alone; the only way to
# leave out the GPU of an Apple silicon Mac). A list of cards to use and a
# list to leave out do not mix; the CPU is chosen with -t, not here. On NVIDIA
# the exact cards are picked; the Vulkan and Metal engines take the first N
# cards and accept only -d 0..N-1
# (--devices, FEARMINER_DEVICES)
# devices = <LIST>

# What to do when -d names a card this machine does not have: match refuses
# the start (E206); first and last keep the configuration and mine on the
# cards present, the per-card lists (--temp-limit 85,80) laid over them from
# the first position on, or from the last back
# (--device-missing, FEARMINER_DEVICE_MISSING)
device_missing = "match"

# Pause a GPU whose core stays at or over this temperature, in degrees
# Celsius, for --temp-hold seconds, until it has cooled to --temp-resume; 0
# turns the core cut-off off. One value for every card, or one per card in -d
# order (85,80,_,90: _ keeps the default, a shorter list leaves the rest at
# it)
# (--temp-limit, FEARMINER_TEMP_LIMIT)
temp_limit = 90

# Core temperature a GPU paused by --temp-limit resumes mining at, in degrees
# Celsius; must be under --temp-limit. One value for every card, or one per
# card in -d order, as --temp-limit
# (--temp-resume, FEARMINER_TEMP_RESUME)
temp_resume = 75

# Pause a GPU whose memory sensor stays at or over this temperature for
# --temp-hold seconds, until it has cooled by --temp-hysteresis; 0 turns the
# memory cut-off off. Cards without the sensor are not judged on it
# (--temp-limit-mem, FEARMINER_TEMP_LIMIT_MEM)
temp_limit_mem = 105

# Pause a GPU whose hotspot sensor stays at or over this temperature for
# --temp-hold seconds, until it has cooled by --temp-hysteresis; 0 turns the
# hotspot cut-off off. Cards without the sensor are not judged on it
# (--temp-limit-hotspot, FEARMINER_TEMP_LIMIT_HOTSPOT)
temp_limit_hotspot = 100

# How far under its limit the memory or hotspot sensor must cool before the
# GPU resumes, in degrees Celsius. The core keeps its own pair, --temp-limit
# and --temp-resume
# (--temp-hysteresis, FEARMINER_TEMP_HYSTERESIS)
temp_hysteresis = 10

# How long a sensor must stay at or over its limit before the GPU is paused,
# in seconds; a shorter spike changes nothing. 0 pauses at the first reading
# (--temp-hold, FEARMINER_TEMP_HOLD)
temp_hold = 15

# Stop the miner (exit code 11) when a paused GPU's core stays at or over this
# temperature for --temp-hold seconds, counted from the pause: the last resort
# against a card that keeps heating while paused. 0, the default, turns it
# off; must be over --temp-limit
# (--temp-shutdown, FEARMINER_TEMP_SHUTDOWN)
temp_shutdown = 0

# Do not open NVML: no GPU sensors (temperatures, fan, power, clock, throttle,
# energy), the thermal cut-off has nothing to read and mining goes on. For a
# driver whose NVML misbehaves
# (--no-nvml, FEARMINER_NO_NVML)
no_nvml = false

# CPU mining threads: a count (8), a percentage of the automatic choice (50%,
# a hint rounded to a thread), a delta of it (-2, +2), or one per algorithm
# (ALGO:16,OTHER:32, with a bare value for the others). The automatic choice
# is 0 on a rig with a GPU (the CPU earns about 0.5% of the rate there for 17%
# of the power) and every thread but two on a machine without one; for an
# algorithm whose engine says what a thread needs of the cache, one thread per
# physical core, capped by the L3 cache. More than the machine can spare
# (every thread but two, and one per card) is capped to that, and the cpu line
# of the log says so
# (--threads, FEARMINER_THREADS)
# threads = <N|N%|-N|ALGO:N,...>

# Mine on integrated GPUs too, even beside a discrete one
# (--igpu, FEARMINER_IGPU)
igpu = false

# Do not act on the checks run before the first connection (driver version,
# compute capability, free GPU memory): the report is still printed, but no
# card is left out and nothing stops the start
# (--skip-preflight, FEARMINER_SKIP_PREFLIGHT)
skip_preflight = false

# Measure the GPU launch geometry again, ignoring the cached result
# (--retune, FEARMINER_RETUNE)
retune = false

# Run the known-answer test of the engines: on a mining run, always at start
# (it is otherwise skipped when the same binary, engine, driver and cards
# passed it before); alone, without a pool or a wallet, run it offline for the
# algorithm of -a (or for ALGO as --self-test=ALGO, or for every one with
# --self-test=all), print the verdict per device and exit 0, or 3 on a failure
# (--self-test, FEARMINER_SELF_TEST)
# self_test = <ALGO>

# Nonces the self-test searches on each card, every one re-hashed on the CPU
# (--self-test-nonces, FEARMINER_SELF_TEST_NONCES)
self_test_nonces = 256

# Re-check every GPU solution on the CPU before it is submitted (`on`, the
# default) or not (`off`): a wrong one is dropped and counted as invalid on
# the card's row instead of rejected by the pool. CPU solutions are not
# re-checked either way
# (--verify-shares, FEARMINER_VERIFY_SHARES)
verify_shares = "on"

# GPU batch size, in nonces per launch: a floor, rounded up to whole passes of
# the card's tuned geometry (the start line says the batch in force)
# (--gpu-batch, FEARMINER_GPU_BATCH)
gpu_batch = 1000000

# CPU batch size, in hashes between cancellation checks
# (--cpu-batch, FEARMINER_CPU_BATCH)
cpu_batch = 1000

# Pause between GPU batches, in milliseconds (0 = none)
# (--throttle, FEARMINER_THROTTLE)
throttle = 0

# List the GPUs this machine can mine on (index, name, PCI id, UUID) and exit;
# with --json, the machine-readable listing (the cards with their memory,
# compute capability, driver, vendor and engine, the CPU, the RAM)
# (--list-devices)
list_devices = false

# With --list-devices or --list-algorithms: print the listing as JSON. With
# --benchmark: print the machine-readable report on stdout (one JSON document,
# docs/benchmark-report.md), the progress on stderr
# (--json)
json = false

[cpu]

# Pin the CPU workers to these logical CPUs, in worker order, instead of the
# automatic placement (one per physical core, spread over the NUMA nodes): a
# hex mask (0xff, bit i for CPU i) or a list (0-7,16-23)
# (--cpu-affinity, FEARMINER_CPU_AFFINITY)
# cpu_affinity = <MASK|LIST>

# The CPU workers' priority, 0 (idle) to 5 (highest), the scale XMRig uses:
# nice 19, 5, 0, -5, -10, -15 on Linux, the thread priority class on Windows.
# Above 2 needs a privilege on Linux. Default: the process's own
# (--cpu-priority, FEARMINER_CPU_PRIORITY)
# cpu_priority = <0-5>

# For an algorithm whose engine asks for them: the MSR tweaks (the CPU's
# prefetchers, XMRig's public values), applied through fearminer-helper before
# the first connection and restored at exit. auto picks the preset from the
# CPU (zen1, zen2, zen3, zen4, zen5, intel) and skips with a coded line, never
# a refusal to start, when the helper is missing or the machine cannot take
# them (a VM, kernel lockdown, no msr module); off writes nothing; a preset
# name or a custom list addr:value:mask,... forces the values, on the
# registers the presets tune only (0x1a4, 0xc0011020 to 0xc0011022,
# 0xc001102b)
# (--msr, FEARMINER_MSR)
msr = "auto"

# For an algorithm whose engine asks for huge pages: reserve 1 GiB pages for
# its dataset (three per NUMA node) when the CPU has them (pdpe1gb), 1 to 3 %
# over 2 MiB pages. Off by default, as in XMRig. Used only where the kernel's
# default huge page size is 1 GiB (default_hugepagesz=1G on the kernel command
# line)
# (--1gb-pages, FEARMINER_1GB_PAGES)
huge_pages_1g = false

# The privileged helper (fearminer-helper), run as sudo -n PATH for the MSR
# tweaks and the huge-page reservation. Default: the installed
# /usr/local/bin/fearminer-helper (the path the sudoers line names), else the
# copy beside the miner's own binary. PATH given is the only path tried: the
# installed helper is not tried behind it, and E601 says so when sudo refuses
# PATH or nothing is there. Nothing usable at PATH is no refusal to start: a
# run that needs it says E601 and mines without the tweaks. Not used when the
# miner is itself root (--allow-root): it then does the same in-process
# (--helper, FEARMINER_HELPER)
# helper = <PATH>

[output]

# Address the stats endpoint listens on
# (--api-bind, FEARMINER_API_BIND)
api_bind = "127.0.0.1:4300"

# Do not serve the stats endpoint
# (--no-api, FEARMINER_NO_API)
no_api = false

# Plain scrolling log instead of the full-screen panel (what a pipe and a dumb
# terminal get anyway)
# (--no-tui, FEARMINER_NO_TUI)
no_tui = false

# No colour in the log, and the panel in the terminal's own colours (NO_COLOR
# in the environment does the same)
# (--no-color, FEARMINER_NO_COLOR)
no_color = false

# Debug-level log
# (--verbose, FEARMINER_VERBOSE)
verbose = false

# Also write the log to this file: one line per record, UTC timestamp, no
# colour, the pool password masked. Appended to, never truncated; rotated by
# size (--log-max-size, --log-keep). Written in both the panel and the plain
# mode
# (--log-file, FEARMINER_LOG_FILE)
# log_file = <PATH>

# Level of the log file, apart from the console's: trace, debug, info, warn or
# error. Default: debug with -v, info otherwise
# (--log-level-file, FEARMINER_LOG_LEVEL_FILE)
# log_level_file = <LEVEL>

# Size, in MB, at which the log file is rotated to <PATH>.1, .2, ...
# (--log-max-size, FEARMINER_LOG_MAX_SIZE)
log_max_size = 10

# Rotated log files kept (<PATH>.1 to <PATH>.N); 0 starts the file over
# (--log-keep, FEARMINER_LOG_KEEP)
log_keep = 5

# Send no telemetry at all: no install id is drawn or kept, and nothing goes
# to telemetry.fearminer.com (see Telemetry below). The signed fee terms are
# still fetched from cfg.fearminer.com
# (--no-telemetry, FEARMINER_NO_TELEMETRY)
no_telemetry = false

# Minutes between two telemetry beats, 5 to 1440: under 5 is raised to 5 and
# over a day lowered to a day, and the log says so
# (--telemetry-interval, FEARMINER_TELEMETRY_INTERVAL)
telemetry_interval = 15

[history]

# Keep this rig's own history in <state dir>/history.bin (`on`, the default)
# or not (`off`): one sample every 10 s for the last 24 h, then one a minute
# for a week, one every five minutes for a month and one an hour beyond, read
# by GET /api/v1/history and by fearminer history. Off writes nothing and
# keeps nothing
# (--history, FEARMINER_HISTORY)
history = "on"

# Days of history kept. Beyond a week the samples are five minutes apart,
# beyond a month an hour apart, so ninety days weigh a few megabytes
# (--history-retention, FEARMINER_HISTORY_RETENTION)
history_retention = 90

# Hard bound on the history file, in MB: the file is laid out to fit it from
# the first byte and never grows past it. The bound wins over
# --history-retention, which is cut back to fit
# (--history-max-size, FEARMINER_HISTORY_MAX_SIZE)
history_max_size = 32

[benchmark]

# Measure the hashrate and the power of this machine and exit; with -a all, or
# a list (-a ALGO,OTHER), every algorithm in turn, then a summary
# (--benchmark)
benchmark = false

# Benchmark length per algorithm, in seconds: 10 by default for one algorithm,
# 60 for several
# (--duration)
# duration = <SECS>

# Deterministic benchmark: the work and every worker's nonce sequence derive
# from this seed, the run ends after --bench-solutions solutions per worker
# instead of --duration, every solution is re-checked on the CPU, and a
# checksum of them is printed; two runs on the same hardware print the same
# checksum, a hardware error does not
# (--bench-seed)
# bench_seed = <N>

# Solutions per worker a seeded benchmark runs to
# (--bench-solutions)
bench_solutions = 4

# Untimed hashing after the engine is ready (its setup, its autotune and its
# first search done), before the clock starts: a card reaches its working
# temperature and clocks first. 0 by default: the clock starts as soon as
# every device is ready
# (--warmup)
warmup = 0

# Write the benchmark's machine-readable report (docs/benchmark-report.md,
# schema fearminer.benchmark/1) to FILE, written aside then renamed, on
# success and on failure alike
# (--report)
# report = <FILE>

[supervisor]

# Run the miner as one process, without the supervisor that restarts it after
# a crash: for systemd, HiveOS or another watchdog that restarts it itself,
# and for debugging
# (--no-supervisor, FEARMINER_NO_SUPERVISOR)
no_supervisor = false

# Seconds the supervisor waits for the mining process to stop after SIGTERM or
# Ctrl+C before killing it
# (--stop-timeout, FEARMINER_STOP_TIMEOUT)
stop_timeout = 8

# Restarts the supervisor allows within --restart-window before it gives up
# (exit code 12) and runs --on-failure
# (--max-restarts, FEARMINER_MAX_RESTARTS)
max_restarts = 5

# The window of --max-restarts, in minutes
# (--restart-window, FEARMINER_RESTART_WINDOW)
restart_window = 30

# What the supervisor does when it gives up: exit, or script:<path> to run
# that script first (FEARMINER_EXIT_CODE, FEARMINER_CAUSE and
# FEARMINER_RESTARTS in its environment), then exit
# (--on-failure, FEARMINER_ON_FAILURE)
on_failure = "exit"

# Run even when another fearminer is already running on this account (the
# single-instance lock is skipped)
# (--allow-multiple, FEARMINER_ALLOW_MULTIPLE)
allow_multiple = false

# Mine as root. Without it a miner started as root exits with code 3: it needs
# no privileges, and a bug or a hijacked configuration would have them all.
# HiveOS runs every miner as root and passes it
# (--allow-root, FEARMINER_ALLOW_ROOT)
allow_root = false

# Clear the crash counters kept per GPU across restarts, then start as usual;
# alone, without a pool, just clear them and exit
# (--reset-crashes)
reset_crashes = false

[watchdog]

# Turn the watchdog off: no hang, hashrate, share or reject check, no
# quarantine; a lost card leaves the others mining either way
# (--no-watchdog, FEARMINER_NO_WATCHDOG)
no_watchdog = false

# Seconds a search may run without a sign of life from the GPU before the card
# is declared hung and the miner exits for a restart (code 10)
# (--hang-timeout, FEARMINER_HANG_TIMEOUT)
hang_timeout = 60

# Seconds a GPU may report no hashes while the other cards mine before the
# miner exits for a restart (code 11); after a 5 min grace at start and after
# a thermal resume
# (--zero-hashrate-timeout, FEARMINER_ZERO_HASHRATE_TIMEOUT)
zero_hashrate_timeout = 300

# Seconds without any accepted share, from any device, after the session
# connected, before the miner moves to the next pool; a second such period on
# the next pool exits for a restart (code 11). 0 turns it off. A single card
# that earns nothing while the others do is judged on its own (ten times its
# expected time between shares, 10 to 60 minutes)
# (--no-share-timeout, FEARMINER_NO_SHARE_TIMEOUT)
no_share_timeout = 1800

# The least a GPU's ten-minute average may be: a share of its reference
# (`50%`, the best ten-minute average seen this session, or
# --hashrate-reference) or an absolute rate (`300M`, `1.2G`). Under it the
# card is Degraded; still under after --hashrate-grace, the miner exits for a
# restart (code 11). The rig's summed average is held to the same bound. 0
# turns it off
# (--hashrate-min, FEARMINER_HASHRATE_MIN)
hashrate_min = "50%"

# The most a GPU's ten-minute average can honestly be, in the same forms; over
# it the figure is wrong and is reported, never restarted. 0 turns it off
# (--hashrate-max, FEARMINER_HASHRATE_MAX)
hashrate_max = 0

# Seconds a GPU may stay under --hashrate-min before the miner exits for a
# restart; 0 never restarts it (Degraded and the alert only)
# (--hashrate-grace, FEARMINER_HASHRATE_GRACE)
hashrate_grace = 300

# The reference the percentages of --hashrate-min and --hashrate-max refer to,
# in H/s (`600M`): one value for every card, or one per card in engine order,
# comma separated. Learnt when not given: the best ten-minute average seen
# this session
# (--hashrate-reference, FEARMINER_HASHRATE_REFERENCE)
# hashrate_reference = <RATE[,RATE...]>

# How many expected share intervals (the difficulty over the card's rate) a
# GPU may go without finding a share, never under 10 minutes, before it is
# Degraded and its search restarted; a second famine exits for a restart (code
# 11). 0 turns it off
# (--share-famine, FEARMINER_SHARE_FAMINE)
share_famine = 5

# Shares of one GPU the pool may refuse in a row (stale ones aside) before the
# card is Degraded until it has a share accepted; also the solutions the CPU
# re-check may refuse within ten minutes. 0 turns it off
# (--max-rejects-device, FEARMINER_MAX_REJECTS_DEVICE)
max_rejects_device = 5

# Shares the pool may refuse in a row, from any device, before the session is
# reconnected; a second such run moves to the next pool. 0 turns it off
# (--max-rejects, FEARMINER_MAX_REJECTS)
max_rejects = 15

# Submits left unanswered by the pool for --submit-timeout, in a row, before
# the session is reconnected; a second such run moves to the next pool. 0
# turns it off
# (--max-no-submit-responses, FEARMINER_MAX_NO_SUBMIT_RESPONSES)
max_no_submit_responses = 10

# Restarts blamed on one GPU within --restart-window before it is Quarantined
# at the next start: left out of mining while the others carry on, until the
# miner is restarted. Never the last device that could mine. 0 turns it off
# (--device-quarantine, FEARMINER_DEVICE_QUARANTINE)
device_quarantine = 3

[notifications]

# Send the alerts to this URL as JSON (POST, format version 1, see the
# README); repeat it, or separate the URLs with commas, for several. Retried
# on a 5xx or a network error, never on a 4xx
# (--notify-url, FEARMINER_NOTIFY_URL)
# notify_url = []

# Send the alerts to a Telegram chat through a bot: the bot's token and the
# chat id, as BOT_TOKEN:CHAT_ID
# (--notify-telegram, FEARMINER_NOTIFY_TELEGRAM)
# notify_telegram = <BOT_TOKEN:CHAT_ID>

# Send the alerts to a Discord channel through its webhook URL
# (--notify-discord, FEARMINER_NOTIFY_DISCORD)
# notify_discord = <WEBHOOK_URL>

# Sign each --notify-url body with HMAC-SHA256 under this secret
# (X-FearMiner-Signature: sha256=<hex>), so the receiver can check it came
# from this miner
# (--notify-secret, FEARMINER_NOTIFY_SECRET)
# notify_secret = <SECRET>

# The least severity that is sent: info, warning, error or critical
# (--notify-min-severity, FEARMINER_NOTIFY_MIN_SEVERITY)
notify_min_severity = "warning"

# Send one test message (a rig_up) to every notifier and the heartbeat's
# /start, print what happened, and exit: 0 when every delivery went through, 1
# otherwise
# (--notify-test)
notify_test = false

# Ping this URL every 60 s (GET; POST with --heartbeat-post), plus <URL>/start
# at startup and <URL>/fail on a critical event, the healthchecks.io
# convention; an Uptime Kuma push URL works as is
# (--heartbeat-url, FEARMINER_HEARTBEAT_URL)
# heartbeat_url = <URL>

# POST the heartbeat with a small JSON body (hashrate, effective hashrate,
# shares, uptime, restarts) instead of a GET
# (--heartbeat-post, FEARMINER_HEARTBEAT_POST)
heartbeat_post = false

[oc]

# Core clock offset in MHz, signed (+100, -50), applied through the driver
# (NVIDIA, driver 520 or later). One value for every card, or one per card in
# -d order (100,_,-50: _ leaves that card alone). Without any OC option the
# miner touches no clock, power limit or fan register. Read back after it is
# set; refused with its code when the driver says no (E703: run as root with
# --allow-root)
# (--cclock, FEARMINER_CCLOCK)
# cclock = <MHZ[,MHZ...]>

# Lock the core clock at this many MHz (what nvidia-smi -lgc does); 0 removes
# the lock. One value for every card, or one per card in -d order. The driver
# cannot read a lock back, so at exit the lock is reset to the driver's
# default
# (--lock-cclock, FEARMINER_LOCK_CCLOCK)
# lock_cclock = <MHZ[,MHZ...]>

# Memory clock offset in MHz, signed (+800, -500). One value for every card,
# or one per card in -d order
# (--mclock, FEARMINER_MCLOCK)
# mclock = <MHZ[,MHZ...]>

# Lock the memory clock at this many MHz (nvidia-smi -lmc), which must be one
# of the steps the card publishes (405, 810, 5001, 10251...; E701 lists them
# otherwise); 0 removes the lock. One value for every card, or one per card in
# -d order
# (--lock-mclock, FEARMINER_LOCK_MCLOCK)
# lock_mclock = <MHZ[,MHZ...]>

# Power limit, in watts (220) or as a percentage of the card's default limit
# (80%), inside the range the card publishes (E702 shows the minimum and the
# maximum otherwise). One value for every card, or one per card in -d order
# (--pl, FEARMINER_PL)
# pl = <W|N%[,...]>

# Fan speed in percent (70%), or auto to give the fan back to the driver's
# curve. One value for every card, or one per card in -d order. A card without
# fan control (a laptop) refuses it (E704)
# (--fan, FEARMINER_FAN)
# fan = <N%|auto[,...]>

# Seconds to wait, after a card has started mining (its first accepted share,
# or 30 s at most), before its core offset and lock are applied: for the rigs
# that crash when the offset lands on a cold card. 0 applies them at start
# with the rest
# (--oc-delay, FEARMINER_OC_DELAY)
oc_delay = 0

# Ignore every OC option and any [oc] section of the file: the miner touches
# no clock, power limit or fan register, and says so at start. For a rig whose
# OC is set outside (HiveOS, Afterburner, a script)
# (--no-oc, FEARMINER_NO_OC)
no_oc = false

# Put every selected card at the driver's defaults (locks removed, offsets at
# 0, the default power limit, the fan on its curve) before the OC options are
# applied
# (--oc-reset-on-start, FEARMINER_OC_RESET_ON_START)
oc_reset_on_start = false

# Run this program once per card before mining starts, directly, never through
# a shell, with FEARMINER_DEVICE, FEARMINER_PCI_BUS, FEARMINER_UUID and
# FEARMINER_ALGO in its environment; 30 s at most, the exit code logged (E707
# when not 0)
# (--oc-script, FEARMINER_OC_SCRIPT)
# oc_script = <PATH>

# A set per algorithm, applied at start for the algorithm mined, over the [oc]
# values above and under the environment and the command line: one table per
# algorithm of the engine index ([oc.quantus], [oc.randomx], [oc.pearl],
# [oc.tensorcash], [oc.commonfoundry]), with any of the six value options
# (cclock, lock_cclock, mclock, lock_mclock, pl, fan), one value for every
# card or one per card in -d order, as under [oc]. --dry-run prints the sets
# and the policy they make.
#
# [oc.quantus]
# cclock = 100
# lock_mclock = "5001,_"
# pl = "80%"

[commands]

# Which commands a running miner takes beyond the reversible ones: read (the
# default: pause, resume, toggle and retune only), operate (restart and stop
# too), sensitive (the wallet, the pools and the overclocking too). A command
# over the level is refused with E217, a valid token or not
# (--unrestricted-api, FEARMINER_UNRESTRICTED_API)
unrestricted_api = "read"

# Run this program when EVENT happens, directly, never through a shell, with
# FEARMINER_EVENT and the event's context in its environment; 30 s at most,
# the exit code logged (E139 when not 0). Repeat it, or separate the hooks
# with commas, for several. The events: start, exit, crash, pause, resume,
# pool-switch, share-rejected-high, low-hashrate, temp-high, device-lost
# (--hook, FEARMINER_HOOK)
# hook = []

# Watch the configuration file and reload it when it changes. Off by default:
# SIGHUP and PUT /api/v1/config reload it either way. A value the new file
# gives that does not validate is refused whole (E220) and the configuration
# in force is kept
# (--watch-config, FEARMINER_WATCH_CONFIG)
watch_config = false

# Run without a console: the process detaches from the terminal and keeps
# mining after the shell that started it is gone. Implies --no-tui (there is
# no screen to draw on); give --log-file to keep the log
# (--background, FEARMINER_BACKGROUND)
background = false

# The whole process's scheduling priority, 0 (idle) to 5 (highest), on the
# same scale as --cpu-priority, which sets the worker threads' priority alone.
# Above 2 needs a privilege on Linux; refused by the OS, it is E613 and the
# miner keeps the normal priority
# (--priority, FEARMINER_PRIORITY)
# priority = <N>