What is the rationale for how the LoadTXSoutSet RPC is set up?

Why is that so? m_assumeutxo_data If you don’t want to trust someone else’s UTXO set, are they hardcoded in the first place? (We are forced Use only that UTXO set version))

The concern is that people place their websites with the instructions “Faster sync times!” UTXO set download included. If such a site becomes popular and then compromises, then this is not possible if the user actually loads a malicious UTXO set and is not acceptable, even if it is simple (what is it in such a UTXO set). It is possible. The attacker will give 1 million btc.)

Place a commitment hash in your source code and you are covered in the Bitcoin Core review ecosystem. I think it’s unfair to call this “deciding by the developer.”

Active Review Community Anyone can see any changes to the source code. Changes to m_assumeutxo_data The values are easily checked (just check the hash of an existing node), and undergoes a lot of scrutiny.
Bitcoin Core has a reproducible build. Anyone, including developers, can take part in building the release and should be bit-identical binary just like what was published. This establishes confidence that the binary that people actually execute matches the released source code. m_assumeutxo_data value.

If we consider “developers” as an entire group of people participating in these processes, it is of course not wrong to state that it is effectively this group that this group is making that decision. However, I think the overall scale and transparency are important. This is not one person who chooses value before release without supervision, as there may be instructions on the website. And of course, users essentially trust this group of people/processes anyway, for the verification software itself, even when they try to minimize the extent to which this trust is needed.

Why? m_assumeutxo_data Set to 840.000 and not the same block assumevalid?

The original idea is that behind suceutxo, it includes automatic snapshots and distribution of snapshots over the network, so users find the source There’s no need.

In such a model, there is a predefined schedule of the height at which the snapshot is created. For example, there may be one per 52,500 blocks (about once per year), and all nodes supporting the feature will take a snapshot at that height when it reaches it and then download it from a P2P network. Keep a few snapshots of The new node starts m_assumeutxo_data Values set to what the last multiple of 52500 was at release can be synchronized from the nodes that provide snapshots on the network. Even if the provider uses software older than the receiver.

Currently, there is no progress on the P2P side of this, but it suggests using a snapshot height schedule that is not tied to the core release of Bitcoin.

I understand that people don’t want them to start trusting random UTXO sets because they wait to sync, but have you not been able to use a per-self UTXO set? As a user, it would be great if you could back up your actual UTXO set, sign it in some way, load + validate it in the future and sync new nodes.

If it’s just you, you can make a backup chainstate Directory (while the node is not running). sasumutxo has many important features in a wide range of distribution models, but should not be applied to personal backups.

Snapshot data is standard. Anyone can create snapshots at a specific height, making it easier for everyone to take the same snapshot file, compare and distribute (potentially from multiple sources, BitTorrent style).
Snapshot loading still includes background revalidation. You will get a node that is immediately synced to a snapshot point and can continue validation from that point, but for security, the node will perform it individually against the background of re-validation of the snapshot itself (from Genesis to Snapshot Points to).

If you fully trust the snapshot creator and loader (as you are both yourself), then the overhead of these features is not necessary. By creating a backup of ChainState (which holds the UTXO set), you can jump to that point of verification at any point, on any system. Because this is a database, it is not comparable byte byte between systems, but it is compatible. The person who “restores” the backup does not perform a background re-validation as it does not know that something created externally is being loaded, but if you ultimately trust the data, this is simply It’s a replica of the work.