Wie kann ich die verbleibende Zeit bis zum Abschluss einer Synchronisierung abschätzen?

Sie können den folgenden Code eingeben, um die verbleibende Zeit in Minuten abzuschätzen. Es tastet den aktuellen Block zu zwei verschiedenen Zeiten ab, um die verbleibende Zeit abzuschätzen. Beachten Sie, dass, wenn sich Ihr aktueller Block während dieser Zeit nicht ändert, er ihn nicht schätzen kann.

Im geth console:

function printSyncForecast() {
    if (!eth.syncing) return "Your node isn't syncing."
    var sampleSeconds = 10
    var currentBlock = eth.syncing.currentBlock;
    admin.sleep(sampleSeconds);
    if (!eth.syncing) return "Your node stopped syncing."
    var blocksSynced = eth.syncing.currentBlock - currentBlock
    var blocksPerMinute = blocksSynced * 60 / sampleSeconds;
    if (blocksPerMinute === 0) return "Current block didn't change; try increasing the sample time";
    var blocksRemaining = eth.syncing.highestBlock - eth.syncing.currentBlock;
    var minutesRemaining = blocksRemaining / blocksPerMinute;
    return "node synced " + blocksSynced + " blocks in " + sampleSeconds + " seconds (" + blocksPerMinute + 
      " blocks/minute.)  If these 📈 continue, node will sync the remaining " + blocksRemaining + " blocks in " + 
      minutesRemaining + " minutes."
}
printSyncForecast()

Hier ist ein Einzeiler von der Befehlszeile mit einer minimierten Version dieses Codes:

geth attach --exec '(function(){if(!eth.syncing)return"Your node isnt syncing.";var n=eth.syncing.currentBlock;if(admin.sleep(10),!eth.syncing)return"Your node stopped syncing.";var e=eth.syncing.currentBlock-n,t=60*e/10;if(0===t)return"Current block didnt change; try increasing the sample time";var c=eth.syncing.highestBlock-eth.syncing.currentBlock;return"node synced "+e+" blocks in 10 seconds ("+t+" blocks/minute.)  If these 📈 continue, node will sync the remaining "+c+" blocks in "+c/t+" minutes."})()'

Sie können versuchen, dies in die Geth-Konsole einzufügen ( geth attach http://localhost:8545um die Konsole zu öffnen, oder eine andere URL, abhängig von Ihrer Konfiguration), und beachten Sie, dass Sie die Blockproduktionsrate für Ihre Interessenkette optimieren müssen. Bei Ethereum wird es beispielsweise zu var networkBlocksPerSec = 1 / 13.2;. Beachten Sie, dass andere Snippets, die online herumschwirren, nicht die Blöcke berücksichtigen, die das Netzwerk während der Synchronisierung erzeugt, sodass sie keine genaue Schätzung liefern! Dieser tut es :)

(function () {

    var secPerSample = 10;
    var sampleWindow = 200;
    var networkBlocksPerSec = 1 / 2.3; // network block time (polygon makes a block every ~2 seconds)
    var decimals = 3;
    
    var dataPoints = [];
    
    var topBlock = eth.syncing.highestBlock;
    var curBlock = eth.syncing.currentBlock;

    
    function checkETA() {
        if (!eth || !eth.syncing) return 'Your node isn\'t syncing.';

        var blocksSynced = eth.syncing.currentBlock - curBlock;
    
        dataPoints.push(blocksSynced);
    
        console.log('\nMade it from block ' + curBlock + ' to block ' + eth.syncing.currentBlock + ' in the last ' + secPerSample + ' seconds (' + blocksSynced + ' blocks)');
    
        if (dataPoints.length > sampleWindow) {
            dataPoints.splice(0, dataPoints.length - sampleWindow); // keep only 100 data points
        }
    
        var avgBlocksPerWindow = 0;
        for (var i = 0; i < dataPoints.length; i++) {
            avgBlocksPerWindow += dataPoints[i];
        }
    
        avgBlocksPerWindow /= dataPoints.length;

        var avgBlocksPerSecond = avgBlocksPerWindow / secPerSample;
    
        console.log('Catching up ' + avgBlocksPerSecond.toFixed(decimals) + ' blocks/sec on average (' + avgBlocksPerWindow.toFixed(decimals) + ' blocks every ' + secPerSample + ' seconds, over last ' + dataPoints.length + ' samples)');
    

        topBlock = eth.syncing.highestBlock;
        curBlock = eth.syncing.currentBlock;

    
        var blocksRemaining = topBlock - curBlock;
        var secondsToReachTopBlock = blocksRemaining / avgBlocksPerSecond;
    
        console.log('With ' + blocksRemaining + ' blocks left to catch up on, getting to highest block known thus far (' + topBlock + ') should take ' + fancyTimeFormat(secondsToReachTopBlock, false));

        var effectiveCatchupRate = avgBlocksPerSecond - networkBlocksPerSec;

        console.log('Network also creates ' + networkBlocksPerSec.toFixed(decimals) + ' blocks/second, making our effective catchup rate ' + effectiveCatchupRate.toFixed(decimals) + ' blocks/sec');

        if (effectiveCatchupRate > 0) {
            var catchupSeconds = blocksRemaining / effectiveCatchupRate;
            var expectedCaughtUpBlock = topBlock + catchupSeconds * networkBlocksPerSec;
    
            console.log('Factoring in the rate of future block creation, we will be synced in ' + fancyTimeFormat(catchupSeconds, false) + ', at block #' + Math.ceil(expectedCaughtUpBlock));
        } else {
            console.log('At this rate, network is producing faster, so we will never catch up');
        }
    }


    function fancyTimeFormat(duration, withSeconds) {   // duration is in seconds
        var ret = ''; // Hours, minutes and seconds  
        var hrs = ~~(duration / 3600);  
    
        if (hrs > 0) ret += hrs + ' hrs ';
    
        ret += ~~((duration % 3600) / 60) + ' mins';

        if (withSeconds) ret += ' ' + (~~duration % 60) + ' secs';
        return ret;
    }
    
    
    var handle = setInterval(checkETA, secPerSample * 1000);

    function stop() {
        clearInterval(handle)
    }

    this.stopChecking = stop;
})()

Um die Ausführung der Funktion in einem Intervall zu stoppen, führen Sie sie stopChecking()in der Geth-Konsole aus