Transaktionen mit einer Wartezeit (mit nLockTime)

Ich würde gerne wissen, ob es Transaktionen, die kann nur auf einige vordefinierte moment. Im Prinzip sollte es möglich sein, verwenden Sie den parameter nLockTime zu warten, für einen bestimmten block-Nr.:

https://en.bitcoin.it/wiki/Protocol_specification#tx

Dies könnte nützlich sein, bestimmte Verträge, aber Ersatz ist noch nicht unterstützt:

Warum ist nicht die Transaktion Ersatz unterstützt?

In jedem Fall scheint es Sie immer noch, im Prinzip, erstellen Sie eine einfache, unreplaceable Transaktion mit einer Wartezeit.

Gibt es irgendein Beispiel, wie eine Transaktion in der blockchain? Wenn nicht, würde es akzeptiert werden, die von den standard-client oder würde es notwendig sein, uns zu überzeugen Bergmann es in einem seiner Blöcke.

UPDATE: Eröffnet eine Diskussion, in https://bitcointalk.org/index.php?topic=131443.0 Tauchen wir weiter.

+278
Alex Profera 01.03.2013, 22:42:43
26 Antworten

Von dem was ich verstehe, Transaktionen werden zusammen in einen block, der Nachweis der Arbeit erfolgt durch die Berechnung eines hash-Wertes für block, dann Hinzugefügt, um die block-Kette. Wenn ein block Hinzugefügt, um die block-Kette, dann ist die Transaktion der block wird betrachtet zu sein, bestätigt.

Wie ist der vollständige Knoten, von dem der block chain abgefragt wird entschieden? Oder wie viele vollständige Knoten-block-Kette ist eine Transaktion überprüft?

Angenommen, ein Angreifer hat einen Gabel-Kette, und lassen Sie uns davon ausgehen, nichts über andere voller Knoten " Ablehnung oder eine Bestätigung über diese Gabel, kann meine Transaktion überprüft werden, die gegen diese Gabel Kette der Angreifer und nicht gegen andere gültige block-Ketten verwaltet von ehrlich voller Knoten?

Angenommen, es gelang mir, die 6 Bestätigungen, aber alle diese Bausteine sind einem Angreifer die Gabel. Ist das ein problem?

+976
M3HD1 03 февр. '09 в 4:24

Mike Hearn gerade gebucht über, wie Netzwerk-Versicherte Verträge, die dieses problem behandeln. Ich finde nicht eine sofortige Fehler mit diesem.

So verstehe ich die vorgeschlagene Lösung:

Jeder, der ein Interesse an einem hohen hash-rate (im Grunde jeder halten eine große Menge von Münzen), initiieren oder kooperieren auf SIGHASH_ANYONECANPAY Transaktionen. Diese sind eine effektive Möglichkeit für die Leute sagen Sachen "ich gelobe 10 BTC für die nächsten miner mine ein block, 100 Gesamt-BTC gespendet wird, in dieser Transaktion ... ansonsten werde ich mein Geld zurück bekommen, die in 5 Häuserblocks"?

Also, wenn Menschen oder Organisationen halten eine große Menge an BTC sehen, dass die Sicherheit ist zu niedrig für Ihren standard, können Sie den chip in ... vorausgesetzt, andere tun dies auch.

+931
antihrist6666 11.02.2018, 10:41:34

Ich lernen, dass, egal ob es um die Transaktionsgebühren, oder in einigen anderen Fällen, Wellen zerstört werden kann.

Was bedeutet es?

Wenn ich eine Gebühr berechnet, bedeutet das, dass niemand mit bekam, dass die Gebühr als eine entsprechende Erhöhung der Bestände in XRPs?

Oder bedeutet es, dass es keine Aufzeichnungen von ihm überall, außer in meine Netzhaut Sehzellen sehen 0.xxx weniger auf meinem Konto und jemand anderes mehr sehen?

+923
Xianwei Zhang 17.02.2017, 17:51:51

Vorausgesetzt, 256-bit-hash-Ausgang, wie sieht die (Durchschnittliche) Anzahl der nonces, die ich brauche, um zu versuchen (zum lösen der proof-of-work-puzzle) wachsen mit der Anzahl der führenden Nullen notwendig, n? Gibt es eine Grenze für diese Zahl?

+917
Cuong Lee 26.10.2012, 08:27:47

Wenn Sie ausgehende Transaktionen werden immer angezeigt, unabhängig davon, wie weit hinter der Synchronisation ist. Keine unbestätigten Transaktionen müssen lange prallte zurück zu Ihren Geldbeutel mit jetzt. Versuchen Sie mal, in der Eingabeaufforderung (.cmd) auf Ihrem computer und geben Sie in:

"C:\Program Files (x86)\Bitcoin\bitcoin-qt" --zapwallettxes=1

Oder versuchen Sie Folgendes:

"C:\Program Files\Bitcoin\bitcoin-qt" --zapwallettxes=1

Ihre bitcoin-core-wallet re-scan und die bitcoins auf Ihrer wallet.

Wenn Sie eingehende Transaktionen, die Sie erwarten, werden Sie nur verlassen, um das bitcoin-core-wallet öffnen, bis es synchronisiert mit dem Datum der bitcoins empfangen wurden. Dies wird wahrscheinlich ein paar Tage dauern.

Hoffe, das hilft...

James

+910
qveer 05.07.2011, 02:18:43

Eine einfache Bitcoin-wallet besteht auf eine weitere Paare von öffentlichen und privaten Schlüsseln (ich sage nur: so einfach wie einige wallet-Struktur ermöglichen deterministischen public-key-Generationen und private Schlüssel, die nur einen Teil der Geldbörse, aber das Prinzip mit public/private Schlüssel bleibt der gleiche). Der "link" Bitcoin zunächst geschieht, während block-generation, wo eine bestimmte Menge an Bitcoins generiert und an die miner die öffentliche Adresse; dies ist lediglich ein Eintrag in der blockchain. Dann diese coins können an andere öffentliche Adressen mithilfe von Transaktionen.

Die am meisten einfache Transaktion hat einen Eingang und einen Ausgang; D. H. er verbringt die Münzen von einer Quelladresse zu einer Zieladresse. Um gültig zu sein, die Höhe der Ausgabe Münzen dürfen nicht den Betrag übersteigen, den der Eingang Münzen und verifiziert werden die Ausgabe-Adresse, Hashwert wird signiert, indem Sie die Eingabe-Adresse " privaten Schlüssel.

In der realen Welt, obwohl, Brieftaschen-Bilanzen werden die Summe aller Eingänge auf, die Brieftasche, so dass, wenn Sie eine Transaktion machen, die software wählen Sie die gewünschte Anzahl von Eingängen zu erhalten, ein Betrag in Höhe von höher, um die gewünschte Transaktion Ausgang + Gebühr. Wenn die Menge mehr als was Sie ausgeben wollen, der Rest kann zurück zu senden, um eine der input-Adresse oder sogar eine neue Adresse Ihrer Brieftasche, so dass Sie im Grunde sich selbst senden wird der übersteigende Betrag an Bitcoins. Jeder nicht ausgegebene Betrag in der Transaktion als Gebühr erhoben, indem der Bergmann die Generierung der block.

Transaktionen können auch sehr viel komplexer sein; Bitcoin ermöglicht eine sehr leistungsfähige scripting-system können Transaktionen zu machen aufwendbare in vielerlei Hinsicht. Lesen Sie mehr über bitcoin-Transaktionen und scripting-system hier:

https://en.bitcoin.it/wiki/Transactions

https://en.bitcoin.it/wiki/Script

Wenn Sie senden eine Transaktion, es wird weitergeleitet an das Netzwerk für die Aufnahme in einen block wenn es geht, gemeinsame Regeln für Transaktionen (Wirksamkeit, Kosten, Größe, etc.). Ein Bergmann wird irgendwann Holen Sie Ihre Transaktion und nehmen es mit einem block (die Transaktionen sind tatsächlich in einem merkle-Baum, dessen Wurzel-Hashwert wird in dem block header - block header-hash ist, der Nachweis der Arbeit, die entsprechend der Schwierigkeit der Anforderung für den block).

+796
user37110 10.10.2016, 22:39:53

Bitcoin ist ein Netzwerk-Protokoll, dass alle Knoten verwenden, um miteinander zu kommunizieren. So lange, wie eine software kann sprechen, dass das Protokoll, es kann dem Netzwerk beitreten. Da Bitcoin-Core ist open-source, die die Protokoll-Informationen sind frei verfügbar für jedermann zu sehen und zu implementieren, die sich an anderer Stelle. Die Protokoll-Informationen sind auch beschrieben auf bitcoin.org.

+738
dunduk 16.08.2010, 14:13:17

Sie können den Zugriff auf die Daten für jede Währung, die auf jedem exchange mit den Märkten API von BitcoinCharts:

Zum Beispiel, für USD:

+726
C Lueless 16.02.2015, 11:10:28

Also habe ich versucht herauszufinden, wie viel läuft das Bitcoin-system wirklich Kosten mit den folgenden Nummern:

  • Insgesamt Bitcoin-Hash Rate: 300.000.000 GH/s
  • Hashrate eines ANTMINER S4 (derzeit eine der effizientesten ASICs): 2.000 GH/s Macht
  • der Stromverbrauch eines ANTMINER S4: 1.400 W
  • Energie Preis: $0.15/kWh

  • 300.000.000 / 2.000 = 150.000 Antminers

  • 150.000 * 1400W = 210.000.000 W
  • 210.000.000 W * 24 Stunden = 5.040.000.000 Wh = 5.040.000 kWh
  • 5.040.000 * $0.15 = 756.000$

Unter Berücksichtigung anderer weniger effizient rigs um die $1.000.000 scheint (theoretisch) realistisch für mich, aber ich kann einfach nicht wickeln meinem Kopf herum Bitcoin kostet $364.000.000 pro Jahr. Was mache ich falsch?

+698
Natalie DesChene 11.05.2010, 17:09:17

Ich versuche zum einrichten eines bitcoin - /altcoin-pool-server, aber ich habe in ein bisschen ein problem, ich habe keine Möglichkeit zu überprüfen, habe ich verbunden mit dem pool ist erfolgreich, und keine Statistiken oder Informationen, die auf den tatsächlichen pool-Operationen. Gibt es eine Möglichkeit, die ich finden konnte, diese Statistiken im litecoin-qt-oder bitcoin-qt? Der getinfo-Befehl scheint nur die Rückkehr Statistiken über den AUFTRAGGEBER, die gegenüber den tatsächlichen pool-info. Ich möchte auch haben Sie automatisch generiert vs erneute Berechnung selbst.

+690
megadraiv 12.09.2012, 12:24:06
Multi-Signatur-Adressen erfordern die m-of-n Signaturen zu ermächtigen, Ausgaben Gelder, die an Sie geschickt.
+669
muhqu 21.03.2013, 09:16:52

Habe ich erfolgreich abgeschlossen, meinen ersten Versuch zu konfigurieren, mein Raspberry Pi zum Bitcoin mining mit einer GekkoScience USB Antstick und Minera; jedoch nach der Installation zusätzliche Antsticks, mein env irgendwie beschädigt wurde, die letztlich dazu führen, mich zu wischen und mein Raspberry Pi und installieren Sie eine neue Kopie von Raspian und Neuinstallation von Minera - meine Frage ist: sollte ich neu kompiliert Minera nach der Installation zusätzliche Antsticks, wie unten in der Abbildung unten gefangen von der Minera -Handbuch-Seite installieren?

enter image description here

Ich habe detaillierte meiner Minera install-Prozess innerhalb der folgenden Gist , wenn das hilft zu klären - im Grunde möchte ich vermeiden, dass jede zukünftige Komplikationen nach der Installation zusätzliche Antsticks oder Bergleute, denn mehr sind auf dem Weg! Danke.

+602
Mariah patrisse Mabalot 04.10.2018, 02:39:39

Ist die transaction malleability die einzige Sache, muss fix in den bitcoin Konsens code zum aktivieren von lightning-Netzwerk umgesetzt werden?

Natürlich, lightning Netzwerk selbst hätte umgesetzt werden müssen, aber ich Frage mich, ob nach Festsetzung der transaction malleability, änderungen an bitcoin selbst ist erforderlich.

Insbesondere dann, wenn die BIP-62 implementiert ist, wäre das genug?

+555
umerk44 13.03.2015, 04:18:33

Es ist ein json-für unit-tests von japanischen Zeichen , die ich überprüfen möchten mit Python, genauer gesagt, mit dieser Gabel pybitcointools, die bip39 Funktionalität.

Unit-tests von Trezor ist python-Eselsbrücke test-Vektoren, die gut funktionieren (in Python 2.7 IME), dies ist jedoch einfach, da es keine Normalisierung von unicode-Dialektik und solche, da alle mnemonische Zeichen sind Kleinbuchstaben Englisch.

Die japanische Felder sind:

  1. Entropie (hex)
  2. Eselsbrücke (Japanisch)
  3. Passwort (Japanisch, scheint das gleiche für alle tests)
  4. Seed (hex, 64-Byte -)
  5. xprv

Also Entropie Samen mnemonic (bip39?), dann mnemonic | Passwort - hashes Samen; Samen fungiert dann als master key für die bip32 xprv? (korrigiert mich wenn ich falsch Liege!?)

Also, vorausgesetzt, es ist so einfach...

  1. wie ist die japanische unicode-text "normalisiert"? (Ist es nur NKFD Unicode-Normalisierung, die Elektron 2.0 hat?)
  2. was bedeutet "normal" bedeutet für die Japaner?
+551
Michael Woyo 14.09.2011, 14:41:06

Was Sie tun können es durchqueren wieder von der Kette zu Tipp über RPC:

  1. rufen Sie getbestblockhash (RPC)
  2. Verwenden blockhash zu nennen, getblock (RPC)
  3. Lesen Sie Größe -> speichern Sie es irgendwo (CSV-Datei, etc.)
  4. Lesen previousblockhash und verwenden Sie es als blockhash für getblock
  5. Goto Schritt 2
+550
user6497 24.06.2010, 17:08:55

Nein, diese Strategie macht keinen Sinn, weil, wie die Blöcke aufgebaut sind in der blockchain. Auch, es ist trivial für die Netz-Teilnehmer verfolgen die Transaktionen werden bestätigt, denn das ist der springende Punkt, der Bergbau und die blockchain.


Es ist möglich, für die Bergleute zu halten, Transaktionen geheim und veröffentlichen Sie Sie, wenn Sie entdecken, einen block. Das kann sinnvoll sein, wenn für eine Transaktion ein Geheimnis in den ersten Platz, und hat besonders große Gebühren.

Aber:

  1. Die meisten Transaktionen sind nicht geheim.
    In der Regel werden Transaktionen weitergeleitet werden, die über das Bitcoin-Netzwerk, um die Bergleute, so dass jeder etwas anderes weiß über die Transaktionen.
  2. Blöcke konkurrieren, in andere Möglichkeiten neben den Transaktionen enthalten.
    Blöcke Referenz Ihre Vorgänger. Daher, wenn zwei Blöcke gefunden werden, zur gleichen Zeit werden Sie beide auf den gleichen Vorgänger. Jedoch nur eine der konkurrierenden block kann ein Teil der längsten Kette, da der folgende block kann nur auf eine oder die andere.
  3. Das problem von versehentlich einschließlich einer bestätigten Transaktion ist nicht vorhanden.
    Jeder Netzwerk-Teilnehmer verfolgt, welche nicht ausgegebene Transaktion Ausgänge (UTXO) vorhanden. Transaktionen, die versuchen, verbringen Sie einen UTXO, dass Sie bereits ungültig sind. Dies beinhaltet doublespends, und eine Wiedergabe von einer bestätigten Transaktion. Da jeder Knoten immer genau überlegen, auf einen block auf die aktuelle blockchain Tipp, es ist trivial zu bemerken, dass eine Transaktion wurde zuvor bestätigt. (Oder eher, dass es nicht mehr verfügbar bestätigt werden.)
+536
Charles Leopizzo 09.09.2012, 10:36:23

Es ist möglich, aber durchaus schwieriger als mit Bitcoin.

Alle NXT-Token/Münzen sind auf dem Netzwerk gespeichert, aber es ist möglich, erstellen Sie ein Konto "offline" ist abgesichert durch eine 256-bit-public-key und nicht setzen Sie Ihre privaten Schlüssel auf das Netzwerk.

Es ist eine Schritt-für-Schritt-Anleitung auf dem NXT-Forum.

+423
SirSaleh 06.10.2014, 12:57:28

Vor einigen Jahren habe ich verschlüsselt meine Bitcoin privaten Schlüssel für den Kühlraum für eine offline-app namens " Bippy. Vor kurzem habe ich versucht, Zugriff auf meine Brieftasche durch entschlüsseln des privaten Schlüssels, aber mein Passwort wurde abgelehnt.

Ich habe aus diesem Bippy Programm wieder, und ich fange an zu vermuten, es ist irgendwie fehlerhaft. Es scheint, dass der private Schlüssel, beginnend mit einer '5' - verschlüsselt mit Bippy - nicht entschlüsseln mit dem gleichen Passwort. Andere Präfixe, scheint zu funktionieren OK.

Nun, diese Bippy app ist open-source und in Python geschrieben, und ich habe es von hier. Ich habe versucht, wie ein test, um zu verschlüsseln, der private Schlüssel 5Ka1Bv4RpKayZygPhZbBcREejqeYwq2isrzwpksg49spgvrtnpw mit Passwort testingOneTwo (es ist eine frische pk, keine bitcoins gibt ;)). In Bippy diese verschlüsselt zu 6PYMN8WT4CW7xLYczLvYfXZCtQWND7XEesk32qbxujmgkhf2v5a2zqanpl, jedoch unter Verwendung des Passwortes schlägt fehl, es zu entschlüsseln, um seine ursprüngliche... ich habe versucht, mehrere andere '5'-private Schlüssel und Passwörter, und das gleiche passiert jedes mal.

Zum Glück das Programm ist open-source; leider, das Projekt scheint aufgegeben, ein paar Jahre zurück und meine Kenntnisse in Python und ist die Verschlüsselung nicht auf einem Niveau gut genug, um zu lokalisieren, die Fehler hier im Spiel, und in der Hoffnung für etwas Hilfe hier :)

+401
Ricglen A Gregorio 29.05.2012, 11:59:54

in meinem Ort hat der Benutzer ein link zu überprüfen, die Transaktionen und seine wallet-Adresse.

jetzt bin ich mit dieser:

blockchain: https://blockchain.info/tx/#{txid}

address_url: https://blockchain.info/address/#{Adresse}

und perfekt für btc mainnet

in meinem code habe ich dies bekommen Sie die Blöcke und Adressen info, meine Frage ist, wie bekomme ich die gleiche Sache, aber mit testnet?

Ich versuchte https://www.blockcypher.com api, aber es funktionierte nicht, keine Hilfe? danke.

was ich will ist den Transaktionen und addressess info von Ihr in meiner website.

es funktioniert bereits, aber nur mit btc main chain

Ich bin mit testnetchain schon: bitcoin.conf testnet=1

kann mir jemand erklären, wie man diese info mit dem testnet?

ist blockcypher oder einer anderen website ähnlich blockchaininfo mir bekommen diese Parameter.

+347
Robert Dilka 27.08.2015, 12:15:00

Die Inflation würde erhöhen Sie den Wert Ihrer Bitcoins. Inflation bedeutet, dass die dollars die Sie verwendet, um zu kaufen die Bitcoins sind weniger Wert, wenn also der Wert der Bitcoins hält stabil, Sie werden lohnt sich jetzt mehr Dollar.

Was würden Sie brauchen Schutz gegen die deflation, der dollar gewinnt an Wert, oder den Wert von Bitcoins fallen aufgrund von änderungen in Angebot, Nachfrage und hype.

+263
JBourne 15.10.2013, 16:25:55

Diese Frage teilweise gefragt, die gleiche Sache, aber bekam nur eine Antwort für die Anzeige der Größe, wenn du den client installiert hast.

Ich möchte wissen, die gesamte blockchain Größe, ohne den client zu installieren und den download der blockchain.

+218
jarzyna 10.12.2016, 08:45:33

Ohne Komplikationen wie Schwierigkeiten, änderungen und temporäre blockchain teilt, können Sie das Modell der block generation time als eine exponentielle Verteilung.

Eine exponentielle Verteilung hat eine Standardabweichung gleich dem Erwartungswert. Dies prognostiziert eine 10-Minuten-Standardabweichung für die Bitcoin.


Die Messung der tatsächlichen Verteilung ist nicht so einfach. Während jeder block enthält einen timestamp, der Zeitstempel ist nicht sehr genau, und manchmal ist die Zeitdifferenz zwischen den Blöcken ist sogar negativ.
Der timestamp ändert sich nicht im Laufe eines einzigen Anteils, und einige Bergleute bewusst Zeitstempel verwenden, die abweichend von der tatsächlichen Zeit

+184
user97034 11.06.2014, 16:47:27

Ich hatte bitcoin core und dummy mir gelöscht, aber ich schickte meine wallet auf dem desktop und jetzt habe ich eine neue Geldbörse, gibt es eine Möglichkeit, um die Brieftasche, die auf meinem desktop wieder in bitcoin core? Ich habe versucht, zu kopieren und einzufügen, aber das funktioniert nicht. Ich ging zu %APPDATA%\roaming\bitcoin, aber konnte nicht ein kopieren und einfügen in es. Jeder Weg, um meine Geldbörse zurück in es. Vielen Dank für Ihre Zeit. RoberT

+172
n0unc3 08.10.2011, 06:41:50

Zuerst: ich bin ein newbite zu altcoin Entwicklung, neben dem generieren einer altcoin von litecoin,
1 - ich habe einen Klon von litecoin mit git clone https://githubcom/litecoin-project/lotecoin.git
2 - ich habe von Kette und Münze Parameter in chainparams.cpp wie unten:

// Copyright (c) 2010 Satoshi Nakamoto
 // Copyright (c) 2009-2015 Die Bitcoin-Kern-Entwickler
 // Verteilt unter der MIT-software-Lizenz finden Sie in der begleitenden
 // Datei KOPIEREN oder http://www.opensource.org/licenses/mit-license.php.

 #include "chainparams.h"
 #include "Konsens/merkle.h"

 #include "tinyformat.h"
 #include "util.h"
 #include "utilstrencodings.h"

 #include <assert.h>

 #include "chainparamsseeds.h"
 #include "arith_uint256.h"

 statische CBlock CreateGenesisBlock(const char* pszTimestamp, const CScript& genesisOutputScript, uint32_t nuhrzeit, uint32_t nNonce, uint32_t nBits, int32_t nVersion, const CAmount& genesisReward)
{
 CMutableTransaction txNew;
 txNew.nVersion = 1;
txNew.vin.resize(1);
txNew.vout.resize(1);
 txNew.vin[0].scriptSig = CScript() << 486604799 << CScriptNum(4) << std::vector<unsigned char>((const unsigned char*)pszTimestamp, (const unsigned char*)pszTimestamp + strlen(pszTimestamp));
 txNew.vout[0].nValue = genesisReward;
 txNew.vout[0].scriptPubKey = genesisOutputScript;

 CBlock genesis;
 genesis.nuhrzeit = nuhrzeit;
 genesis.nBits = nBits;
 genesis.nNonce = nNonce;
 genesis.nVersion = nVersion;
genesis.vtx.push_back(MakeTransactionRef(std::move(txNew)));
genesis.hashPrevBlock.SetNull();
 genesis.hashMerkleRoot = BlockMerkleRoot(genesis);
 Rückkehr genesis;
}

/**
 * Aufbau der genesis-block. Beachten Sie, dass die Ausgabe seiner generation
 * Transaktion kann nicht ausgegeben werden, da es nicht ursprünglich vorhanden, in der
 * Datenbank.
*
 * CBlock(hash=000000000019d6, ver=1, hashPrevBlock=00000000000000, hashMerkleRoot=4a5e1e, nuhrzeit=1231006505, nBits=1d00ffff, *nNonce=2083236893, vtx=1)
 * CTransaction(hash=4a5e1e, ver=1, vin.size=1, vout.size=1, nLockTime=0)
 * CTxIn(COutPoint(000000, -1), coinbase *04ffff001d0104455468652054696d65732030332f4a616e2f32303039204368616e63656c6c6f72206f6e206272696e6b206f66207365636f6e64206261696c6f757420**666f722062616e6b73)
 * CTxOut(nValue=50.00000000, scriptPubKey=0x5F1DF16B2B704C8A578D0B)
 * vMerkleTree: 4a5e1e
*/

 statische CBlock CreateGenesisBlock(uint32_t nuhrzeit, uint32_t nNonce, uint32_t nBits, int32_t nVersion, const CAmount& genesisReward)
{
 const char* pszTimestamp = "Teheran Times, Stonica gewinnt endlich";
 const CScript genesisOutputScript = CScript() << ParseHex("040184710fa689ad5023690c80f3a49c8f13f8d45b8c857fbcbc8bc4a8e4d3eb4b10f4d4604fa08dce601aaf0f470216fe1b51850b4acf21b179c45070ac7b03a9") << OP_CHECKSIG;
 zurück CreateGenesisBlock(pszTimestamp, genesisOutputScript, nuhrzeit, nNonce, nBits, nVersion, genesisReward);
}

 void CChainParams::UpdateVersionBitsParameters(Konsens::DeploymentPos d, int64_t nStartTime, int64_t nTimeout)
{
 Konsens.vDeployments[d].nStartTime = nStartTime;
 Konsens.vDeployments[d].nTimeout = nTimeout;
}

/**
 * Main-Netz
*/
/**
 * Was macht ein gutes checkpoint-block?
 * + Umgeben von Blöcken mit vernünftigen Zeitstempel
 * (keine Blöcke, bevor Sie mit einem Zeitstempel nach, keine nach mit
 * Zeitstempel vor)
 * + Enthält keine seltsame Transaktionen
*/

 Klasse CMainParams : öffentliche CChainParams {
öffentlichkeit:
 CMainParams() {
 strNetworkID = "main";
 Konsens.nSubsidyHalvingInterval = 840000;
 Konsens.BIP34Height = 710000;
 Konsens.BIP34Hash = uint256S("00000000b2c50d03d4d0bdd38681775ce522f137518145d6b3c913b7dd4423e5");
 Konsens.BIP65Height = 918684; // bab3041e8977e0dc3eeff63fe707b92bde1dd449d8efafb248c27c8264cc311a
 Konsens.BIP66Height = 811879; // 7aceee012833fa8952f8835d8b1b3ae233cd6ab08fdb27a771d2bd7bdc491894
 Konsens.powLimit = uint256S("00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"); 
 Konsens.nPowTargetTimespan = 3.5 * 24 * 60 * 60; // 3.5 Tage
 Konsens.nPowTargetSpacing = 2.5 * 60;
 Konsens.fPowAllowMinDifficultyBlocks = false;
 Konsens.fPowNoRetargeting = false;
 Konsens.nRuleChangeActivationThreshold = 6048; // 75% 8064
 Konsens.nMinerConfirmationWindow = 8064; // nPowTargetTimespan / nPowTargetSpacing * 4
 Konsens.vDeployments[Konsens::DEPLOYMENT_TESTDUMMY].bit = 28;
 Konsens.vDeployments[Konsens::DEPLOYMENT_TESTDUMMY].nStartTime = 1199145601; // 1. Januar 2008
 Konsens.vDeployments[Konsens::DEPLOYMENT_TESTDUMMY].nTimeout = 1230767999; // Dezember 31, 2008

 // Bereitstellung von BIP68, BIP112, und BIP113.
 Konsens.vDeployments[Konsens::DEPLOYMENT_CSV].bit = 0;
 Konsens.vDeployments[Konsens::DEPLOYMENT_CSV].nStartTime = 1485561600; // 28 Januar 2017
 Konsens.vDeployments[Konsens::DEPLOYMENT_CSV].nTimeout = 1517356801; // Januar 31st, 2018

 // Bereitstellung von SegWit (BIP141, BIP143, und BIP147)
 Konsens.vDeployments[Konsens::DEPLOYMENT_SEGWIT].bit = 1;
 Konsens.vDeployments[Konsens::DEPLOYMENT_SEGWIT].nStartTime = 1485561600; // 28 Januar 2017
 Konsens.vDeployments[Konsens::DEPLOYMENT_SEGWIT].nTimeout = 1517356801; // Januar 31st, 2018

 // Der besten Kette sollte mindestens so viel Arbeit.
 Konsens.nMinimumChainWork = uint256S("0x00000000000000000000000000000000000000000000000ba50a60f8b56c7fe0");

 // Standardmäßig davon ausgehen, dass die Unterschriften, die in den Vorfahren dieses Blocks gültig sind.
 Konsens.defaultAssumeValid = uint256S("0x29c8c00e1a5f446a6364a29633d3f1ee16428d87c8d3851a1c570be8170b04c2"); //1259849

/**
 * Das message-start-string ist so konzipiert, unwahrscheinlich im normalen Daten.
 * Die Zeichen werden nur selten genutzt oberen ASCII, gelten nicht als UTF-8, und produzieren
 * eine große 32-bit-integer mit beliebiger Ausrichtung.
*/
 pchMessageStart[0] = 0x0b;
 pchMessageStart[1] = 0xd0;
 pchMessageStart[2] = 0xb6;
 pchMessageStart[3] = 0xdb;
 nDefaultPort = 9335;
 nPruneAfterHeight = 100000;
 //statische CBlock CreateGenesisBlock(uint32_t nuhrzeit, uint32_t nNonce, uint32_t nBits, int32_t nVersion, const CAmount& genesisReward)
 genesis = CreateGenesisBlock(1511279793, 1251189192, 0x1d00ffff , 1, 50 * MÜNZE);
 Konsens.hashGenesisBlock = genesis.GetHash();

 /* 
 // berechnen der Genesis-Block
 // Reset-genesis
 Konsens.hashGenesisBlock = uint256S("0x");
 std::cout << std::string("Beginnen Berechnung Mainnet Genesis Block:\n");
 if (true && (genesis.GetHash() != Konsens.hashGenesisBlock)) {
 LogPrintf("Berechnung von Mainnet Genesis Block:\n");
 arith_uint256 hashTarget = arith_uint256().SetCompact(genesis.nBits);
 uint256 hash;
 genesis.nNonce = 0;
 // Dies herauszufinden, einen gültigen Hashwert und der Nonce, wenn Sie
 // Erstellung einer anderen genesis-block:
 // uint256 hashTarget = CBigNum().SetCompact(genesis.nBits).getuint256();
 // hashTarget.SetCompact(genesis.nBits, &fNegative, &fOverflow).getuint256();
 // while (genesis.GetHash() > hashTarget)
 while (UintToArith256(genesis.GetHash()) > hashTarget)
{
++genesis.nNonce;
 wenn (genesis.nNonce == 0)
{
 LogPrintf("NONCE GEWICKELT, erhöht die Zeit");
 std::cout << std::string("NONCE GEWICKELT, increment time:\n");
++genesis.nuhrzeit;
}
 wenn (genesis.nNonce % 10000 == 0)
{
 LogPrintf("Mainnet: nonce %08u: hash = %s \n", genesis.nNonce, genesis.GetHash().ToString().c_str());
 // std::cout << strNetworkID << "nonce:" << genesis.nNonce << "time:" << genesis.nuhrzeit << "hash:" << genesis.GetHash().ToString().c_str() << "\n";
}
}
 std::cout << "Mainnet ---\n";
 std::cout << "nonce:" << genesis.nNonce << "\n";
 std::cout << "time:" << genesis.nuhrzeit << "\n";
 std::cout << "hash:" << genesis.GetHash().ToString().c_str() << "\n";
 std::cout << "merklehash:" << genesis.hashMerkleRoot.ToString().c_str() << "\n";
 // Mainnet --- nonce: 296277 Zeit: 1390095618 hash: 000000bdd771b14e5a031806292305e563956ce2584278de414d9965f6ab54b0
}
 std::cout << std::string("Finished Berechnung Mainnet Genesis Block:\n");


*/





//printf("%s\n",Konsens.hashGenesisBlock.Tostring().c_str());
 std::cout << std::string("EINGABE:\n");
 assert(Konsens.hashGenesisBlock == uint256S("0x00000000b2c50d03d4d0bdd38681775ce522f137518145d6b3c913b7dd4423e5"));
 assert(genesis.hashMerkleRoot == uint256S("0xf8621e34b0dcd43361fe589702e06aa79992229bfbca57d058d8561635c30fbe"));
 std::cout << std::string("BESTANDEN\n");

 printf("min nBit: %08x\n", Konsens.powLimit);

 // Beachten Sie, dass dieser mit der bits-Dienst flag, die meisten unterstützen nur eine Teilmenge der möglichen Optionen
 //vSeeds.emplace_back("Saatgut-ein.stonicacoin.loshan.co.uk", true);
 //vSeeds.emplace_back("dnsseed.thrasher.io", true);
 //vSeeds.emplace_back("dnsseed.stonicacointools.com", true);
 //vSeeds.emplace_back("dnsseed.stonicacoinpool.org", true);
 //vSeeds.emplace_back("dnsseed.koin-project.com", false);

 base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,127);
 base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,65);
 base58Prefixes[SCRIPT_ADDRESS2] = std::vector<unsigned char>(1,56);
 base58Prefixes[SECRET_KEY] = std::vector<unsigned char>(1.176 Meldungen);
 base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x88, 0xB2, 0x1E};
 base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x88, 0xAD, 0xE4};

 vFixedSeeds = std::vector<SeedSpec6>(pnSeed6_main, pnSeed6_main + ARRAYLEN(pnSeed6_main));

 fDefaultConsistencyChecks = false;
 fRequireStandard = true;
 fMineBlocksOnDemand = false;

 checkpointData = (CCheckpointData) {
{
 { 0, uint256S("0x00000000b2c50d03d4d0bdd38681775ce522f137518145d6b3c913b7dd4423e5")},

}
};

 chainTxData = ChainTxData{
 // Daten als block db42d00d824950a125f9b08b6b6c282c484781562fa8b3bd29d6ce4a2627c348 (Höhe 1259851).
 1502955334, // * UNIX-Zeitstempel der letzten bekannten Zahl von Transaktionen
 1, // * Anzahl der Transaktionen zwischen genesis und timestamp
 // (tx=... - Nummer in der SetBestChain Debuggen.log-Zeilen)
 0.00 // * geschätzte Anzahl von Transaktionen pro Sekunde nach timestamp
};
}
};

/**
 * Testnet (v3)
*/
 Klasse CTestNetParams : öffentliche CChainParams {
öffentlichkeit:
 CTestNetParams() {
 strNetworkID = "test";
 Konsens.nSubsidyHalvingInterval = 840000;
 Konsens.BIP34Height = 76;
 Konsens.BIP34Hash = uint256S("8075c771ed8b495ffd943980a95f702ab34fce3c8c54e379548bda33cc8c0573");
 Konsens.BIP65Height = 76; // 8075c771ed8b495ffd943980a95f702ab34fce3c8c54e379548bda33cc8c0573
 Konsens.BIP66Height = 76; // 8075c771ed8b495ffd943980a95f702ab34fce3c8c54e379548bda33cc8c0573
 Konsens.powLimit = uint256S("00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
 Konsens.nPowTargetTimespan = 3.5 * 24 * 60 * 60; // 3.5 Tage
 Konsens.nPowTargetSpacing = 2.5 * 60;
 Konsens.fPowAllowMinDifficultyBlocks = true;
 Konsens.fPowNoRetargeting = false;
 Konsens.nRuleChangeActivationThreshold = 1512; // 75% für testchains
 Konsens.nMinerConfirmationWindow = 2016; // nPowTargetTimespan / nPowTargetSpacing
 Konsens.vDeployments[Konsens::DEPLOYMENT_TESTDUMMY].bit = 28;
 Konsens.vDeployments[Konsens::DEPLOYMENT_TESTDUMMY].nStartTime = 1199145601; // 1. Januar 2008
 Konsens.vDeployments[Konsens::DEPLOYMENT_TESTDUMMY].nTimeout = 1230767999; // Dezember 31, 2008

 // Bereitstellung von BIP68, BIP112, und BIP113.
 Konsens.vDeployments[Konsens::DEPLOYMENT_CSV].bit = 0;
 Konsens.vDeployments[Konsens::DEPLOYMENT_CSV].nStartTime = 1483228800; // Januar 1, 2017
 Konsens.vDeployments[Konsens::DEPLOYMENT_CSV].nTimeout = 1517356801; // Januar 31st, 2018

 // Bereitstellung von SegWit (BIP141, BIP143, und BIP147)
 Konsens.vDeployments[Konsens::DEPLOYMENT_SEGWIT].bit = 1;
 Konsens.vDeployments[Konsens::DEPLOYMENT_SEGWIT].nStartTime = 1483228800; // Januar 1, 2017
 Konsens.vDeployments[Konsens::DEPLOYMENT_SEGWIT].nTimeout = 1517356801; // Januar 31st, 2018

 // Der besten Kette sollte mindestens so viel Arbeit.
 Konsens.nMinimumChainWork = uint256S("0x0000000000000000000000000000000000000000000000000000364b0cbc3568");

 // Standardmäßig davon ausgehen, dass die Unterschriften, die in den Vorfahren dieses Blocks gültig sind.
 Konsens.defaultAssumeValid = uint256S("0xad8ff6c2f5580d2b50bd881e11312425ea84fa99f322bf132beb722f97971bba"); //153490

 pchMessageStart[0] = 0xfd;
 pchMessageStart[1] = 0xd2;
 pchMessageStart[2] = 0xc8;
 pchMessageStart[3] = 0xf1;
 nDefaultPort = 19335;
 nPruneAfterHeight = 1000;

 genesis = CreateGenesisBlock(1511279793, 0, 0x1d00ffff , 1, 50 * MÜNZE);
 Konsens.hashGenesisBlock = genesis.GetHash();
 //assert(Konsens.hashGenesisBlock == uint256S("0x"));
 //assert(genesis.hashMerkleRoot == uint256S("0x"));

vFixedSeeds.clear();
vSeeds.clear();
 // nodes mit Unterstützung für servicebits filtern sollte an der Spitze
 //vSeeds.emplace_back("testnet-seed.stonicacointools.com", true);
 //vSeeds.emplace_back("seed-b.stonicacoin.loshan.co.uk", true);
 //vSeeds.emplace_back("dnsseed-testnet.thrasher.io", true);

 base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,111);
 base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,196);
 base58Prefixes[SCRIPT_ADDRESS2] = std::vector<unsigned char>(1,58);
 base58Prefixes[SECRET_KEY] = std::vector<unsigned char>(1,239);
 base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x35, 0x87, 0xCF};
 base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94};

 vFixedSeeds = std::vector<SeedSpec6>(pnSeed6_test, pnSeed6_test + ARRAYLEN(pnSeed6_test));

 fDefaultConsistencyChecks = false;
 fRequireStandard = false;
 fMineBlocksOnDemand = false;

 checkpointData = (CCheckpointData) {
{
 {0, uint256S("")},
}
};

 chainTxData = ChainTxData{
 // Daten als block 3351b6229da00b47ad7a8d7e1323b0e2874744b5296e3d6448293463ab758624 (Höhe 153489)
//1502953751,
//382986,
//0.01
};

}
};

/**
 * Regression-test
*/
 Klasse CRegTestParams : öffentliche CChainParams {
öffentlichkeit:
 CRegTestParams() {
 strNetworkID = "regtest";
 Konsens.nSubsidyHalvingInterval = 150;
 Konsens.BIP34Height = 100000000; // BIP34 nicht aktiviert regtest (weit in der Zukunft, so block v1 nicht abgelehnt tests)
 Konsens.BIP34Hash = uint256();
 Konsens.BIP65Height = 1351; // BIP65 aktiviert regtest (Verwendet in rpc-Aktivierung tests)
 Konsens.BIP66Height = 1251; // BIP66 aktiviert regtest (Verwendet in rpc-Aktivierung tests)
 Konsens.powLimit = uint256S("7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
 Konsens.nPowTargetTimespan = 3.5 * 24 * 60 * 60; // zwei Wochen
 Konsens.nPowTargetSpacing = 2.5 * 60;
 Konsens.fPowAllowMinDifficultyBlocks = true;
 Konsens.fPowNoRetargeting = true;
 Konsens.nRuleChangeActivationThreshold = 108; // 75% für testchains
 Konsens.nMinerConfirmationWindow = 144; // Schneller als normal für regtest (144 statt 2016)
 Konsens.vDeployments[Konsens::DEPLOYMENT_TESTDUMMY].bit = 28;
 Konsens.vDeployments[Konsens::DEPLOYMENT_TESTDUMMY].nStartTime = 0;
 Konsens.vDeployments[Konsens::DEPLOYMENT_TESTDUMMY].nTimeout = 999999999999ULL;
 Konsens.vDeployments[Konsens::DEPLOYMENT_CSV].bit = 0;
 Konsens.vDeployments[Konsens::DEPLOYMENT_CSV].nStartTime = 0;
 Konsens.vDeployments[Konsens::DEPLOYMENT_CSV].nTimeout = 999999999999ULL;
 Konsens.vDeployments[Konsens::DEPLOYMENT_SEGWIT].bit = 1;
 Konsens.vDeployments[Konsens::DEPLOYMENT_SEGWIT].nStartTime = 0;
 Konsens.vDeployments[Konsens::DEPLOYMENT_SEGWIT].nTimeout = 999999999999ULL;

 // Der besten Kette sollte mindestens so viel Arbeit.
 Konsens.nMinimumChainWork = uint256S("0x00");

 // Standardmäßig davon ausgehen, dass die Unterschriften, die in den Vorfahren dieses Blocks gültig sind.
 Konsens.defaultAssumeValid = uint256S("0x00");

 pchMessageStart[0] = 0xfa;
 pchMessageStart[1] = 0xbf;
 pchMessageStart[2] = 0xb5;
 pchMessageStart[3] = 0xda;
 nDefaultPort = 19444;
 nPruneAfterHeight = 1000;

 genesis = CreateGenesisBlock(1511279793, 0, 0x1d00ffff , 1, 50 * MÜNZE);
 Konsens.hashGenesisBlock = genesis.GetHash();
 assert(Konsens.hashGenesisBlock == uint256S("0x9"));
 assert(genesis.hashMerkleRoot == uint256S("0x"));

 vFixedSeeds.clear(); //!< Regtest-Modus nicht über einen festen Samen.
 vSeeds.clear(); //!< Regtest-Modus keinen DNS-Samen.

 fDefaultConsistencyChecks = true;
 fRequireStandard = false;
 fMineBlocksOnDemand = true; 

 checkpointData = (CCheckpointData) {
{
 {0, uint256S("530827f38f93b43ed12af0b3ad25a288dc02ed74d6d7857862df51fc56c416f9")},
}
};

 chainTxData = ChainTxData{
0,
0,
0
};

 base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,111);
 base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,196);
 base58Prefixes[SCRIPT_ADDRESS2] = std::vector<unsigned char>(1,58);
 base58Prefixes[SECRET_KEY] = std::vector<unsigned char>(1,239);
 base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x35, 0x87, 0xCF};
 base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94};
}
};

 static std::unique_ptr<CChainParams> globalChainParams;

 const CChainParams &Params() {
assert(globalChainParams);
 return *globalChainParams;
}

 std::unique_ptr<CChainParams> CreateChainParams(const std::string& Kette)
{
 wenn (chain == CBaseChainParams::MAIN)
 return std::unique_ptr<CChainParams>(neue CMainParams());
 else if (Kette == CBaseChainParams::TESTNET)
 return std::unique_ptr<CChainParams>(neue CTestNetParams());
 else if (Kette == CBaseChainParams::REGTEST)
 return std::unique_ptr<CChainParams>(neue CRegTestParams());
 throw std::runtime_error(strprintf("%s: Unbekannter Kette %s.", __func__, Kette));
}

 void SelectParams(const std::string& Netzwerk)
{
SelectBaseParams(Netzwerk);
 globalChainParams = CreateChainParams(Netzwerk);
}

 void UpdateVersionBitsParameters(Konsens::DeploymentPos d, int64_t nStartTime, int64_t nTimeout)
{
 globalChainParams->UpdateVersionBitsParameters(d, nStartTime, nTimeout);

Wie Sie vielleicht wissen die bitcoin-Entwickler es versäumt hat, die genesis mining block-code aus source-code veröffentlicht in github, aber ich habe zum Glück fand einige Stück code in blogs und es funktionierte, dann habe ich berechnet die neue Genesis-hash, Merkelroot hash-und Nonce und in die code-wie Sie oben sehen können. Wurde der code korrekt compiliert, und ich habe nicht Assertion failed-Nachricht für Genesis-block, aber ich habe eine andere Fehlermeldung, die Sie sehen können, in debug.log wie folgt:

 2017-12-15 07:31:33 



















 2017-12-15 07:31:33 Stonicacoin version v0.15.0.1-gba8ed3a93be
 2017-12-15 07:31:33 InitParameterInteraction: parameter der Interaktion: -whitelistforcerelay=1 -> Einstellung -whitelistrelay=1
 2017-12-15 07:31:33 Vorausgesetzt, die Vorfahren der block 29c8c00e1a5f446a6364a29633d3f1ee16428d87c8d3851a1c570be8170b04c2 gültige Unterschriften.
 2017-12-15 07:31:33 Mit der "standard" - SHA256 implementation
 2017-12-15 07:31:33 Mit RdRand als eine weitere Entropie-Quelle
 2017-12-15 07:31:33 Standard-Daten-Verzeichnis /home/kevin/.stonicacoin
 2017-12-15 07:31:33 Mit Daten-Verzeichnis /home/kevin/.stonicacoin
 2017-12-15 07:31:33 config-Datei /home/kevin/.stonicacoin/stonicacoin.conf
 2017-12-15 07:31:33 Mit maximal 125 automatische verbindungen (1024 file descriptors available)
 2017-12-15 07:31:33 16 MiB aus 32/2 angefordert für den Signatur-cache speichern kann, 524288 Elemente
 2017-12-15 07:31:33 16 MiB aus 32/2 beantragt für die Ausführung von Skript-cache speichern kann, 524288 Elemente
 2017-12-15 07:31:33 Mit 8 threads für die Skript-überprüfung
 2017-12-15 07:31:33-scheduler-thread starten
 2017-12-15 07:31:33 HTTP: erstellen von work queue-Tiefe 16
 2017-12-15 07:31:33 Keine rpcpassword set - zufällige cookie-Authentifizierung
 2017-12-15 07:31:33 Generierte RPC-Authentifizierung cookie /home/kevin/.stonicacoin/.cookie
 2017-12-15 07:31:33 HTTP: ab 4 worker-threads
 2017-12-15 07:31:33 Cache-Konfiguration:
 2017-12-15 07:31:33 * Mit 2.0 MiB für block-index-Datenbank
 2017-12-15 07:31:33 * Mit 8.0 MiB für Kette-state-Datenbank
 2017-12-15 07:31:33 * Verwendung 440.0 MiB für in-memory-UTXO-set (plus bis zu 4,8 MiB unbenutzt mempool Raum)
 2017-12-15 07:31:33 init message: Loading block-index...
 2017-12-15 07:31:33 Eröffnung LevelDB in /home/kevin/.stonicacoin/blocks/index
 2017-12-15 07:31:33 Geöffnet LevelDB erfolgreich
 2017-12-15 07:31:33 Mit der Verschleierung der Schlüssel für die /home/kevin/.stonicacoin/blocks/index: 0000000000000000
 2017-12-15 07:31:33 LoadBlockIndexDB: letzter block Datei = 0
 2017-12-15 07:31:33 LoadBlockIndexDB: letzter block Datei-Informationen: CBlockFileInfo(Blöcke=0, size=0, Höhe=0...0, time=1970-01-01...1970-01-01)
 2017-12-15 07:31:33 Überprüfung der blk-Dateien sind vorhanden...
 2017-12-15 07:31:33 LoadBlockIndexDB: Transaktion index deaktiviert
 2017-12-15 07:31:33 Initialisierung der Datenbanken...
 2017-12-15 07:31:33 Pre-allocating bis zu position 0x1000000 in blk00000.dat
 2017-12-15 07:31:33 Eröffnung LevelDB in /home/kevin/.stonicacoin/chainstate
 2017-12-15 07:31:33 Geöffnet LevelDB erfolgreich
 2017-12-15 07:31:33, Schrieb neue verschleiern Schlüssel für die /home/kevin/.stonicacoin/chainstate: 77f259e28117a4e1
 2017-12-15 07:31:33 Mit der Verschleierung der Schlüssel für die /home/kevin/.stonicacoin/chainstate: 77f259e28117a4e1
 2017-12-15 07:31:33 init-Nachricht: Zurückspulen Blöcke...
 2017-12-15 07:31:33 block index 11ms
 2017-12-15 07:31:33 No wallet-Unterstützung einkompiliert!
 2017-12-15 07:31:33-FEHLER: ReadBlockFromDisk: Fehler im block-header auf CBlockDiskPos(nFile=0, nPos=8)
 2017-12-15 07:31:33 *** Failed to read block
 2017-12-15 07:31:33-Fehler: Fehler: Ein schwerwiegender interner Fehler aufgetreten, siehe debug.log für details

Ich fand, dass dieser Fehler(zB. FEHLER: ReadBlockFromDisk: Fehler im block-header auf CBlockDiskPos(nFile=0, nPos=8) ) auftreten, in CheckProofOfWork Funktion, die in pow.cpp Jede Empfehlung ist willkommen.

+119
user35762 12.02.2017, 03:19:02

Da Sie einige gemeinsame Auseinandersetzung mit Systemen, kann ich herausfinden, in code, wie senden Sie Sie an die richtige Kette?

+108
iksanovidl 28.10.2016, 23:59:50

Ich bin immer noch versuchen, herauszufinden, wie das multigateway exchange funktioniert bei nxt. ich sehe, du kannst deine bitcoins und andere altcoins in das system und den Handel oben auf der asset exchange mit dem nxt-wallet erstellen einer dezentralen Austausch. meine Bedenken sind:

  • Tun meine bitcoins / altcoins springen eine zentrale wallet wie, wie die typischen Börsen heute funktionieren?

  • Wer kontrolliert die Münze Brieftaschen und was ist, wenn Sie muss neu gestartet werden?

  • Was hindert die multigateway-admins-vom laufen Weg mit unseren Münzen?

  • Was sind einige große Vorteile im Vergleich zu typischen Börsen heute wie cryptsy / poloniex / bter?

+35
Reclzz 22.03.2018, 11:51:39

Fragen mit Tag anzeigen