Skip to content
Crypto.world

Research

Instalación, configuración y utilización de un nodo Bitcoin en Linux

The paper addresses the practical gap between "run a Bitcoin node" as generic advice and the concrete technical decisions a node operator actually faces: which build options to enable, where to place…

Instalación, configuración y utilización de un nodo Bitcoin en Linux
arXiv
2601.09748
Published
2026-01-12
Authors
Jose Eduardo Ulloa, Diego R. Llanos

AI summary

Overview

Research area: Blockchain infrastructure and systems engineering — specifically the operation of a Bitcoin full node (Bitcoin Core) on GNU/Linux, its on-disk data structures, and the performance effects of node configuration parameters.

Technical level: Intermediate. The paper assumes familiarity with the Linux command line, compiling software from source, and basic Bitcoin concepts, but explains node/miner distinctions and file purposes from first principles.

Scope (one sentence): A hands-on, empirically documented walkthrough of compiling Bitcoin Core v29.0 from source on Ubuntu, running it as a systemd service, completing a full initial block download (IBD), auditing every file and directory the node produces, and measuring how txindex and prune change node behaviour and storage footprint.

What This Paper Is About

The paper addresses the practical gap between "run a Bitcoin node" as generic advice and the concrete technical decisions a node operator actually faces: which build options to enable, where to place the blockchain data, which configuration parameters matter, and what each one costs in disk, RAM, or query capability. The authors set out to document the full lifecycle — source compilation, service configuration, synchronization, and file-system output — and then to test configuration parameters empirically on the same running node. The stated goal is to produce a reproducible guide plus a baseline of measured resource figures that future node-performance research or blockchain-query tooling can build on.

Key Contributions

  1. A reproducible source-build procedure for Bitcoin Core v29.0 on Linux, using CMake with -DWITH_SQLITE=ON -DENABLE_WALLET=ON -DWITH_ZMQ=ON, an isolated datadir at /opt/BLOCKCHAIN, rpcauth credentials generated with rpcauth.py, and a systemd unit for persistence and restart-on-failure.

  2. A measured full IBD profile: a bash script polling bitcoin-cli every 30 minutes, logging block height and verificationprogress to CSV, capturing a from-scratch sync from block 304263 to height 894549.

  3. A systematic audit of the Bitcoin Core data directory, explaining the function and observed size of banlist.json, blocks/ and its LevelDB index, chainstate/, debug.log, fee_estimates.dat, indexes/txindex/, peers.dat, and settings.json.

  4. Controlled before/after experiments on configuration parameters (txindex, prune, and — per the abstract's scope — dbcache, maxmempool, maxconnections), measured on the same node with a deliberately chosen pair of test transactions: one old (block #100000) and one recent (block #898576).

Main Findings

  • IBD completed in roughly 23 hours. Processing began 29 April at 05:54 from block 304263; at 30 April 05:00 the height was 894549, meaning approximately 590,000 blocks downloaded and validated in that window. The authors state this demonstrates a full node can sync in under 24 hours given adequate hardware, network, and configuration.

  • verificationprogress plateaus near the end of sync by design. The metric rose continuously toward 1 but stabilized or oscillated slightly near completion, which the authors attribute to Bitcoin Core's internal progress estimator recalibrating against recent network activity — not to an error. Completion required both blocks = headers and initialblockdownload = false.

  • Full (unpruned) chain storage measured at ~471 GiB. The blocks/ directory held more than 9,000 blk/rev files with mode 0600, owned by the bitcoin user, created progressively over the sync.

  • UTXO set snapshot at block 847254: txouts 82454865, transactions 89805073, disk_size 447277290 bytes (~447 MB), bogosize 6169726781, total_amount 19975766.22532526.

  • txindex=1 costs ~58 GB but enables txid-only lookups. After switching to txindex=0 and restarting, getindexinfo returned an empty object, and getrawtransaction <txid> 1 failed with error -5 ("No such mempool transaction. Use -txindex or provide a block hash…") for both the old and recent test transactions. Supplying the block hash made the same lookups succeed, confirming that disabling the index saves disk and speeds startup but removes txid-only historical queries.

  • prune=550 shrank blocks/ to 796M and made old blocks unretrievable. After restart, getblockchaininfo returned error -28 ("Pruning blockstore …") during the initial prune, which took a few minutes of unavailability. Post-prune state reported pruned: true, pruneheight: 898283, size_on_disk: 553096761, prune_target_size: 576716800, automatic_pruning: true. Requesting block #100000 afterwards returned "Block not available (pruned data)", while the recent block remained accessible. chainstate/ occupied about 4.2 GB.

  • debug.log grows large and persistent. The file was approximately 210 MB with 909,217 lines, created 29 April 2025 and last modified 23 May 2025, indicating uninterrupted operation. Its opening lines record Bitcoin Core version v29.0 (release build), the SSE4/SSE4.1/AVX2 SHA256 implementation, RdSeed/RdRand entropy sources, the txindex="1" config argument, and "Using at most 125 automatic connections".

  • fee_estimates.dat (~250 KB) is flushed roughly hourly, with log entries of the form "Flushed fee estimates to fee_estimates.dat". estimatesmartfee 1 returned feerate 0.00003145 with blocks 2; estimatesmartfee 0 was rejected with error -8, "Invalid conf_target, must be between 1 and 1008".

  • peers.dat (~2.6 MB) supported 10 active peer connections, inspected via getpeerinfo, with fields including servicesnames (NETWORK, WITNESS, NETWORK_LIMITED, P2P_V2), relaytxes, pingtime, minping, subver, bytessent/bytesrecv, and connection_type.

  • banlist.json (221 bytes) and settings.json (~190 bytes, mode 0600) remain at their auto-generated defaults, each containing only a warning against manual editing; banned_nets was empty.

  • Results for dbcache, maxmempool, and maxconnections are not available in the supplied text. The content is truncated at the start of the dbcache section (a value range beginning "approximately 450–50" is cut off), so no figures for those three parameters can be reported here.

Methodology in Plain English

The authors took a single commodity desktop — an Intel Core i5-8400 with 6 cores, 16 GB of RAM, and a 2 TB disk — and turned it into a full Bitcoin node. Instead of downloading a prebuilt binary, they cloned the official Bitcoin repository, checked out tag v29.0, installed build dependencies from Ubuntu's repositories, and compiled with CMake, explicitly enabling the wallet, SQLite, and ZeroMQ support so that the resulting node could later serve as a data source for analytics tools.

They put the blockchain on a dedicated directory (/opt/BLOCKCHAIN) owned by a dedicated bitcoin user, wrote a minimal bitcoin.conf with txindex=1 and generated RPC authentication, and registered the daemon under systemd so it starts at boot and restarts on failure. During the first sync they ran a small bash loop that asked the node for its block height and verificationprogress every 30 minutes and appended the answers to a CSV — a low-effort way to get a time series of sync performance.

After sync, they listed and measured every generated file and folder, using ls -lhR, du -sh, stat, file, and targeted bitcoin-cli calls (gettxoutsetinfo, getpeerinfo, getblockchaininfo, estimatesmartfee, getindexinfo, getrawtransaction). For the configuration experiments they changed one parameter at a time on the same node, restarting between changes and observing the effect immediately before and after. Because txindex=1 is incompatible with pruning, they ordered the tests deliberately: disable txindex first, then enable pruning, then proceed to the remaining parameters. They picked one transaction buried in block #100000 and one in block #898576 as fixed probes, so that pruning's effect on old versus recent data could be compared directly.

Why This Matters

The paper provides a concrete, measured baseline for what a home-scale Bitcoin node actually costs in time, disk, and query capability — figures that are usually asserted informally rather than recorded. For research, it demonstrates that node-level instrumentation (periodic polling of verificationprogress, file-system accounting) is cheap to implement and yields data suitable for comparing configurations or identifying bottlenecks during IBD.

Real-world applications:

  • Block explorer and analytics backends: the txindex experiment quantifies the trade-off (about 58 GB of index) for services that need to look up arbitrary transactions by txid.
  • Low-resource and embedded deployments: the prune=550 results (blocks directory reduced to 796M, node still fully validating) show what storage floor is achievable without losing consensus participation.
  • Node operator guidance and onboarding material: the step-by-step build, systemd unit, and file-by-file directory explanations double as a teaching reference.
  • Fee-estimation and peer-connectivity diagnostics: the fee_estimates.dat and peers.dat sections show how to verify that a node's fee suggestions and P2P connections are healthy.

Industry relevance: self-hosted validation underpins custody, payment processing, and regulatory verification workflows where relying on a third-party API is unacceptable. Documenting the resource envelope and the query restrictions of each configuration helps teams size infrastructure and pick parameters deliberately rather than by default.

Future Directions

  • Complete and report the dbcache, maxmempool, and maxconnections experiments. The abstract promises these; the supplied text stops before any results, so the effect of cache size on IBD throughput, mempool memory behaviour, and connection limits remains an open measurement.
  • Repeat the sync under contrasting configurations (with and without txindex, with and without pruning) and compare the CSV time series, as the authors themselves suggest, to isolate how each option shifts sync duration and resource use.
  • Extend the monitoring beyond a single machine and a single run. The paper's own framing calls for comparing scenarios and identifying bottlenecks; a multi-hardware, multi-network baseline would make such comparisons meaningful.
  • Build the query tooling the data directory enables. With txindex enabled and ZeroMQ notifications available in the build, the natural next step is a blockchain query or visualization layer, which the authors explicitly name as a motivation for their configuration choices.

Target Audience

Linux system administrators and technically comfortable Bitcoin users who want to run and understand their own node; students and instructors in systems, distributed-systems, or blockchain courses looking for a reproducible lab exercise; and developers or researchers building blockchain data-query tools who need to know exactly what Bitcoin Core writes to disk and what each configuration parameter costs. Readers seeking protocol theory, cryptography, or consensus-algorithm analysis will not find it here — this is an operations and measurement paper.

Authors’ abstract

This paper documents the installation, configuration, and operation of a full Bitcoin node in a Linux environment, from manual compilation of the source code to complete synchronization with the network. The technical phases of the process are described, the main files generated by Bitcoin Core are analyzed, and the effects of the parameters txindex, prune, dbcache, maxmempool, and maxconnections are empirically studied. System resources during the block download (IBD)…

The full abstract on arXiv
Read the original paper