Où réside avec précision la confiance d'un instantané?

Voici comment l'importationfonctionnepour vous:

• Voustéléchargez uninstantané àpartir d'une clé USBtrouvée dans une ruelle sombre
• Vous commencez à l'importer,il affiche lebloc de hachage qu'ilimporte
• Vousenregistrezplusieursendroits que ce hachageesten effet de la chaîneprincipale
• S'il vérifie,vous le laissez continuer

Voici ce que l'instantané doit contenir (variante complète):

• L'état actuel dugrand livre (soldes,droits de crise,etc.)
• L'en-tête deblocet les opérations de la chaîneentière

Voici commentilest luet vérifié (pasnécessairement dans l'ordre):

• Lesen-têtes deblocs sont hachés localementet,étant donné que chaqueen-tête debloc contient le hachage de sonprédécesseur,laprocédure d'importation veille à ce quetous lesen-têtesinclus dans l'instantanéforment une chaîne qui commence aublocimportéet finit à la Genèse attendue de Mainnet
• Les opérations de chaquebloc sont hachéeset les listes defonctionnement résultantes sont comparées à cellesincluses dans lesen-têtes deblocimportés
• Le contexteestimporté,clépartoucheet les hachages de chaquetouche sont recalcules localement
• Le hachageglobal du contexte,quiinclut les hachages detoutes les clés,est calculéet laprocédure d'importation s'assure qu'il correspond au hachage écrit dans l'en-tête debloc duprédécesseur
• Leprotocole actuelest récupéréen lisant une clé spécifique dans le contexte,de sorte qu'ilest vérifié aussi carilfaitpartie du contexte hachage
• Enfin,pour obtenir des valeurs résultant de l'application de chaquebloc,telle que la durée de vie actuelle des opérations,et quine sontpasincluses dans le contexte,une seule application deblocs (utilisation duprotocole recueilli ci-dessus)esteffectuéepour obtenir Ces valeurs,et leproblème de contexte résultantest également vérifié

Pour valider denouveauxblocs après cela,ce que lenœud abesoinest le contexte de cebloc,quelques valeurs de résultat de la dernière application debloc,ainsi que quelquesen-têtes deblocet des opérations dupassé,quenous venons demontrer avoir été vérifié.

TL; DR: Les hachages contenant des hachages contenant d'autres hachages contenantencoreplus de hachageset quejusqu'à ce que lebloc de Genesis,et jusqu'à chaqueentrée du contexte,plus une seuleexécution de validation deblocagepourfaire vraiment sûr . Il vous appartient de vérifier lepremier hachage de la série surplusieurs sites Web ounœud,puis laprocédure d'importationfait le reste.

Here is how the import works for you:

• you download a snapshot from a usb key found in a dark alley
• you start importing it, it displays the block hash it is importing
• you check in several places that this hash is indeed from the main chain
• if it checks up, you let it continue

Here is what the snapshot must contain (full variant):

• the current state of the ledger (balances, staking rights, etc.)
• the block header and operations of the whole chain

Here is how it is read and checked (not necessarily in order):

• the block headers are hashed locally, and since each block header contains the hash of its predecessor, the import procedure makes sure that all the headers included in the snapshot form a chain that starts at the imported block, and ends up at the expected genesis of mainnet
• the operations of each block are hashed, and the resulting lists of operation hashes are compared to the ones included in the imported block headers
• the context is imported, key by key, and the hashes of each key are recomputed locally
• the global hash of the context, which includes the hashes of all the keys, is computed, and the import procedure makes sure that it matches the hash written in the block header of the predecessor
• the current protocol is retrieved by reading a specific key in the context, so it is checked too as it is part of the context hash
• finally, to get some values that are the result of applying each block, such as the current lifetime of operations, and that are not included in the context, a single block application (using the protocol gathered above) is performed to get these values, and the resulting context hash is also checked

To validate new blocks after that, what the node needs is the context at that block, a few result values from the last block application, and a few block headers and operations from the past, all of which we've just shown to have been checked.

TL;DR: Hashes containing hashes that contain other hashes containing even more hashes, and that up to the genesis block, and up to each and every entry in the context, plus just a single run of block validation to make really sure. It is up to YOU to check the first hash of the series on more than one website or node, and then the import procedure does the rest.

Lafiducie s'appuie sur deux éléments:

1. Le hachage du dernierbloc de l'instantané (est-ce vraiment sur la chaîne officielle?)
2. Le code source de votrenoeud (est-ce que celafait vraiment ce que vouspensez que c'est?)

pour (1),vous devez vérifierplusieurs sources de confiance. Vouspouvez vérifier sur TZScan ou un autreexplorateur debloc que le hachageest dans la chaîneprincipale. Vouspouvez égalementinterroger directement lesnœudspublics.

Ensuite,si le hachageest correct,votrenœud validera automatiquementtoutes les données de l'instantané,carelles leferaient si lesblocsprovenaient d'autresnœuds du réseau. Donc,si vousfaites confiance au code source de votrenœud,tout doit être vérifiéet toutes les donnéesnon valides seraientjetées.

par validation,je veux dire:

1. Vérifiez que leproblème de contexteest celui quiest attendu (le contexteest stocké dans un arbre demerkleinformatique un hachageglobal du contexte)
2. Appliquez chaquebloc de l'instantané à sontour,c'est-à-dire appliquer lestransactionset autres opérations dans le contexteprécédentpour calculer lenouveau contexte. Vérifiez que le contextegénéré a lemême hachage que dans lebloc.

The trust relies in two elements:

1. the hash of the last block in the snapshot (is it really on the official chain ?)
2. the source code of your node (is it really doing what you think it does ?)

For (1), you have to check multiple trusted sources. You can check on TzScan or another block explorer that the hash is in the main chain. You can also directly query public nodes.

Then, if the hash is correct, your node will automatically validate all the data in the snapshot, as it would do if the blocks were coming from other nodes on the network. So, if you trust the source code of your node, everything should be checked, and any invalid data would be discarded.

By validation, I mean:

1. Check that the context hash is the one expected (the context is stored in a Merkle tree computing a global hash of the context)
2. Apply each block in the snapshot in turn, i.e. apply the transactions and other operations on the previous context to compute the new context. Check that the generated context has the same hash as in the block.