Wo kann ich herunterladen eine Momentaufnahme der Blitz Netzwerk-Topologie?

Ich will zur Untersuchung der Eigenschaften des Blitz-Netzwerk-Diagramm. Gibt es eine Möglichkeit zu erhalten, einen relativ frischen snapshot mit Knoten und Kanäle (z.B. im JSON-format)? Es gibt mehrere Forscher (z.B. aufgeführt in dieser Frage), aber AFAIK keiner von Ihnen stellt die zugrunde liegenden Daten zum download.

(Konnte ich nur starten meine eigenen Knoten, und die Abfrage der Daten mit allnodes / allchannels oder einen ähnlichen Befehl, aber das erfordert die Synchronisierung, ein nicht-beschnitten voller Knoten, die ich versuche zu vermeiden im moment.)

UPD: 1ML enthält einige JSON (achten Sie auf die JSON-button auf verschiedenen Seiten). Zum Beispiel, https://1ml.com/testnet/node?json=true gibt das JSON-Beschreibung der top-50 Knoten. Ich habe nicht den Weg gefunden, um diese Daten für alle Knoten aber.

UPD2: eine Verwandte Frage: Beschaffung von Lightning Netzwerk-graph-Daten.

+742
trudydsmall 25.09.2011, 07:23:23
27 Antworten

Das Welt-BIP liegt bei $74 Billionen Fußnote: ein nach Angaben der Weltbank im Jahr 2017. Die max-Versorgung von Bitcoin mit 108 - base-Einheiten als 2.100 Billionen Satoshis.

Wenn Bitcoin ist weltweit die Geld, Märkte und Immobilien, nicht darunter Schulden noch Derivate, die Bewertung von Bitcoin könnte:

Globale Aktienmärkte: $73 Billionen
Die Globale Geldmenge: $90.4 Billionen
Global Real Estate: $217 Billionen
Total: $380.4 Billionen Fußnote: b



Mit einem $380.4 Billionen Wirtschaft und 2.100 Billionen satoshis in der Existenz gibt es viel zu gehen um. Zusätzlich, aufgrund der Knappheit Modell gebaut, in bitcoin (21 Millionen max supply), brauchen wir keine zusätzlichen bitcoins oder mehr Dezimalstellen, die Bewertung von Bitcoin wird sich natürlich ändern, mit unserer Wirtschaft.

Ich glaube, wir verwenden Bitcoin als eine form der digitalen gold wieder andere digitale Währungen und online-Marktplätze, so dass Menschen und Unternehmen zu bewegen, credits von einem online-Marktplatz zu einer anderen oder von einer Währung in eine andere.

eine Der $74 Billionen Globalen Wirtschaft in Einem Diagramm:
http://www.visualcapitalist.com/74-trillion-global-economy-one-chart/

b die Ganze Welt ist Geld und Märkte in Einer Visualisierung:
http://money.visualcapitalist.com/worlds-money-markets-one-visualization-2017/

+998
Masi Alessandro 03 февр. '09 в 4:24

Sagen irgendein Land beschließt, irgendwie blockieren alle ausgehenden Stellaren verbindungen für 30 Minuten. Mit einer Abstimmung Konsens, dass Stellar hat Ketten in beiden Netzwerken Fortschritt mit einer ähnlichen Geschwindigkeit. Nach der Netzwerk-split vorbei ist, wird es zwei Stellare Netzwerke mit einer Geschichte auseinander.

Wie würde ein solches Ergebnis gelöst bzw. vermieden werden, mit der neue Konsens sich ändert? Gibt es eine Möglichkeit zu bestimmen, welche Netzwerk-Status korrekt ist nach dem split? Können die kleineren split-Netzwerk wissen, dass es die split-und pause-Annahme von Transaktionen?

+991
Imran Hossain 11.05.2012, 23:04:30

Ich bin nur daran interessiert zu wissen, wie Sie den transfer in die website von poloniex von bitcoins bitshares

+984
pyobum 15.05.2015, 09:54:55

Es hängt davon ab, wie viel Informationen Sie vermissen.

Ein Wallet Import Format-Taste ist base58 kodiert. Jedes Zeichen im Schlüssel sein kann das einer von 58 Zeichen.

Sie erwähnen in den Kommentaren, dass Sie fehlen 21 Zeichen. Vorausgesetzt, Sie wissen genau, welche 21 Zeichen fehlen (d.h., Sie wissen, dass die ersten 21 fehlen), haben Sie 21^58, oder 4.88336... × 10^76 Möglichkeiten. Dies ist außerhalb der Reichweite von bruteforcing.

Außerdem, wenn Sie nicht wissen, welche 21 Zeichen fehlen, haben Sie viele, viele weitere Möglichkeiten, wie Sie brauchen nicht nur zum Durchlaufen alle 58 Möglichkeiten für jedes Zeichen, aber auch versuchen, alle Ihre mögliche Standorte innerhalb der Taste.

Es sei denn, Sie sind in der Lage, mehr Informationen zu finden, die Schlüssel können nicht wiederhergestellt werden.

+983
gaudisu 06.02.2016, 10:44:49

Da mt.gehex schließen musste seine Europa-Büro, gibt es einen anderen exchange-Annahme von SEPA-überweisungen?

Senden einen Draht zu den HK office kostet viel mehr als eine SEPA-überweisung an mich, und ich möchte vermeiden, dass zusätzliche Kosten, wenn möglich.

+928
Joe Buddy 15.09.2016, 15:42:10

Denken Sie es so: Bitcoins können gestohlen werden, die von Menschen mit Armen private key control "gehackt". Aber wenn diese Leute Ihre Bitcoins gestohlen, was tun Sie? Sie beschweren sich über es online, und damit auch andere Menschen es hören.

Dann werden diejenigen Menschen, die Sie hören, über Sie zu sich selbst sagen: "gut, meine private-key-Steuerung ist ziemlich schlecht, ich kann einfach gehackt!" Dann werden einige von Ihnen zumindest lernen, sich zu schützen, vielleicht durch die Verwendung eines hardware-wallet wie Trezor oder Ledger.

Diejenigen, die keine Verbesserung Ihrer Praktiken entweder irgendwann Ihre Gelder gestohlen, oder Sie werden sehen, weitere Beispiele und deren Verhalten wird sich selbst zu korrigieren.

Auch wenn es einen plötzlichen Anstieg der Diebstähle würde es eine MENGE der Berichterstattung in den Medien über ihn, und noch mehr Menschen würden lernen, wie um sich zu schützen, durch diese gute private-key-Verfahren.

Weil dieses, die Menge der Bitcoins, die gestohlen wird jährlich dazu neigen wird, in Richtung einer kleinen Prozentsatz. Natürlich, wenn die Bitcoin sah aus, wie es sein würde, die Globale Währung, die Sie sich vorstellen können, dass das schon reichen-den Kapitalisten würden nur kaufen, eine ganze Menge von Bitcoin, so würde es nicht machen, dass viel von einem Unterschied zu Ihrem Leben und zu positionieren.

+898
aBrav 07.02.2010, 04:27:21

Schließlich entdeckt der fix: hexhash niedriger sein Fall:

string hexHash = BitConverter.ToString(hash).Replace("-", "").ToLower();
+864
mayaloyal 25.06.2010, 08:18:49

Diese Seite: Blöcke sagte Bergbau ist eigentlich zur Lösung eines mathematischen Problems, aber Lesen von Block-Hash-Algorithmus nicht viel helfen. Ich habe auch versucht zu Lesen bitcoind-source-code, aber code Lesen braucht viel mehr Zeit als das Lesen der Dokumentation:)

Und ich habe geschrieben eine einfache json-rpc-client aufrufen getwork () - Methode zum abrufen von "Daten", aber was soll ich als Nächstes tun, um diese "Daten"?

Jemand könnte erklären, den mining-Prozess in programmer ' s view?

+820
m6devin 21.05.2010, 10:35:22

enter image description here

Die letzten Transaktionen waren dabei eine Menge Zeit, um zu bestätigen und jetzt habe ich meine funds sind unbestätigt. Was ist passiert? Was kann ich tun? Danke für Eure Hilfe

+795
Peter Odonoghue 03.01.2018, 17:12:51

Ich bin ein High-Frequency Trader und müssen, um eine Maschine so nah wie möglich an Bitmex. Ich habe versucht, machen Sie einen Traceroute-aber es ist hinter Cloudfare, so ist es nicht möglich, zu wissen, die realen datacenter-Standort.

+706
Pramod Babu 25.11.2015, 06:51:31

Ich habe bitcoin im blockchain.info (wobei ich die privaten Schlüssel) vor dem 25. Okt.

Die Börse/wallet kann ich verwenden, um den split der bitcoin in BTC und die BTG, so dass ich Sie verkaufen können separat vor dem 1. Nov 2017?

+639
JakesCreative 28.10.2017, 22:24:47

Basierend auf dem bitcoin-wiki, es ist hier ausgelagert

Linux
Standardmäßig Bitcoin wird seine Daten hier:
~/.bitcoin/
+601
makaronnik19781 26.07.2010, 10:02:07

Tun, ich muss zuerst zur übertragung von BTC zu einem öffentlichen bitcoin-Adresse im Besitz der wallet-Anbieter?

Ja.

Ist es einfach so, dass (vorausgesetzt, ich bin richtig oben), wird die wallet-Anbieter weiß, dass meine Waage-Kette und wird eine überweisung auf meine Adresse auf-Kette?

Ja.

Ich habe vergeblich gesucht, aber nicht finden konnten, eine detaillierte Erklärung, wie off-chain-Transaktionen arbeiten.

Deshalb gibt es mehrere Möglichkeiten, es zu tun. Der einfachste Weg dies zu tun ist, um einen service, der hält eine Datenbank der Benutzer und der Datensätze, wie viel Bitcoin jeder hat. Aus der Sicht der blockchain, es gibt einen großen Haufen an Bitcoins, und nur der service braucht, um zu verfolgen, deren Bitcoins sind deren.

Eine andere Möglichkeit ist es, nachzuverfolgen, wer wem was Bitcoins mit einer verteilten Datenbank, wie Offene Transaktionen oder Welligkeit. Dadurch verringert sich die Nachfrage auf Sie, um die Datenbank sicher und gesichert, aber ist komplizierter.

+517
dasha252342 18.04.2018, 13:43:22

Können Sie verfolgen Sie Ihre Zahlung, wenn Sie eine Transaktion von person zu person für ein Haus mieten, wenn der Verkäufer Sie nicht Folgen Sie durch mit Ihrem Ende der Transaktion, und nicht senden Sie die Schlüssel erhalten Sie Ihr Geld zurück?

Oder in anderen Worten gibt es eine Aufzeichnung der Transaktion, so können Sie behaupten, ein Streit oder die Spur der person, die nicht Folgen durch?

Welche Sicherheit habe ich in dieser Hinsicht zum Beispiel bewerbe ich mich bei Ihnen für die Vermietung im Haus, aber ich fand heraus, dass Sie in den Staaten und ich bin in Kanada, so dass Sie senden Sie mir, Sie Tasten, aber Sie wollen die Zahlung zunächst durch btc wallet also, wenn ich das tun, und senden Sie die bitcoins und die er nicht senden Sie mir die Schlüssel und ich finde heraus, dass es ein Betrug war gibt es eine Möglichkeit, mich zu erholen, meine Zahlung?

+509
dave kay 26.03.2019, 10:33:09

Ich habe eine website, wo Benutzer senden kann und Auszahlungen mittels Bitcoin. Ich möchte Ihnen die Möglichkeit geben, die Verwendung verschiedener Gebühren (niedrig, Mittel und hoch), anstatt eine Feste Gebühr oder zu lassen bitcoind wählen Sie die Gebühr. Ich kann nicht setup ein Standard-Gebühr oder es verändert werden, zur Laufzeit, weil dann, wenn ein Benutzer entscheidet sich für eine hohe Gebühr und eine untere, könnte es passieren, dass der Benutzer mit der hohen Gebühr zugeordnet ist als low-oder Umgekehrt.

Also, nach einiger recherche komme ich zu dem Schluss, dass es notwendig ist, bauen die Transaktion von der UTXOS, dass mein Knoten hat. Allerdings ist es schwierig für mich zu Ende, um zu verstehen, wie man diese Aufgabe durchzuführen. Ich gebe ein Beispiel, um zu erklären, mein problem: Wenn der Knoten UTXOS ist 1BTC hat ein user von 0,1 BTC in der wallet-service und will zurücktreten 0.07 BTC. Ich verstehe, dass die Schritte wären die folgenden:

  1. Liste aller nicht ausgegebenen Transaktionen
  2. Wählen Sie ein oder mehrere Eingänge zu schaffen, die Transaktion
  3. Die Gebühr errechnet sich aus der Subtraktion zwischen der Summe der ein-und Ausgänge

Meine Zweifel, in diesem moment wäre:

  1. Wenn ich das richtig verstanden habe, für jede eingehende Transaktion, die wir haben, werden wir eine unverbrauchte Transaktion, die es uns ermöglichen, verbringen die verfügbaren Mittel; Dann, so lange wie Sie haben in einer Datenbank die richtige balance, um jeden Benutzer (Aktualisierung, dass die balance mit den entsprechenden Gebühren beim abheben von Geld), also, ich sollte nur die gleiche UTXO generiert, die von jedem Nutzer bei der Hinterlegung btcs Oder ist es möglich andere UTXOs so lange als die Menge ist die gleiche?

  2. Ich habe gelesen, in bitcointalk, dass den Eingängen des raw-Transaktion muss kleiner oder gleich der Ausgänge der Transaktion. Ist es nicht möglich, die Eingänge höher als die outs und "return" das überschüssige Mittel wieder zu einem wallet von meinem Knoten?

  3. Wie kann ich die Berechnung der Gebühr eingesetzt? Ich meine, ich kann entscheiden, dass ich verwenden möchten, X satoshis/kb aber wie kann ich berechnen die Gebühr, die die Transaktion zu müssen, bevor ich ihn erstellen? Denn wenn ich das richtig verstanden habe, die Größe der Transaktion, die ich bekomme, sobald ich Sie erstellt habe solche Transaktion. Ich weiß nicht, ob es eine Möglichkeit gibt die Berechnung, dass die Transaktion belegt in bytes / kilobytes

Ich habe nicht gefunden, zu viele Informationen über Sie, so dass, wenn jemand kann mir helfen, ich würde es zu schätzen wissen.

+487
ZLNK 19.07.2019, 09:10:16

Warum hat der Satoshi-client nicht verwenden, blockieren synchrone Kommunikation mit Gleichaltrigen? Ich denke, das ist Brei einfacher als die aktuellen asynchronen Schema.

Ich meine, nachdem ein Knoten sendet eine Anfrage, wartet er die Antwort in einer blockierenden Weise, mit einem timeout-Frist. Nachdem die Antwort eingetroffen ist, beginnt er zu senden der nächsten Anforderung. Nicht diese Weise haben Sie eine bessere Kontrolle über die Kommunikation Kontext?

+413
Sniri 10.10.2014, 20:15:47

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.

+375
DGuttentag 02.08.2010, 12:06:28

Bei btgexplorer ich sah, dass ich einige BTG. Ich möchte behaupten, dass es von von blockchain.info wallet. Ich folgte diesem Artikel https://medium.com/@kuzdogan/how-to-claim-your-bitcoin-gold-from-blockchain-info-or-other-wallets-e7ff4242ecf2 aber ich kann Coinomi Brieftasche. Ich mag zu verwenden, exodus Brieftasche.

Wenn ich wieder meine bitcoin-wallet (mit 12 Wörter aus blockchain.info) in exodus, werde ich noch in der Lage sein, um meine blockchain.info Brieftasche?

+281
Pencildrummer 01.06.2011, 04:53:25

Mir ist klar, dass dies möglicherweise ein Duplikat, jedoch habe ich nicht wirklich gesehen, eine ausreichende Antwort auf die Frage, abgesehen von 'warten'.

Ich habe eine Transaktion gestern von einer blockchain wallet ein Justcoin Brieftasche. Es war schon eine kleine Transaktion (test-Transaktion, da dies mein Erster) Unten ist die Informationen, die ich aus der blockchain:

Gebühren 0.0001 BTC

Geschätzte BTC Getätigt 0.00000001 BTC

Größe 258 (bytes)

Empfangene Zeit 2014-08-20 14:27:54

Geschätzte Bestätigung Mal Innerhalb Von 6 Blöcken (Mittlere Priorität)

Die Transaktions-ID ist: https://blockchain.info/tx/5ea993b10e772f1e31218a02b843adc18a0e4d1176b3127f0170c5c08bb0361c

Ich habe das problem mit diesem ist, dass es zu stoppen alle anderen Transaktionen, die ich machen will. Immer wenn ich versuchen, mehr zu bewegen erhebliche zahlen, erhalte ich den Fehler: "Ohne Freie Ausgänge Zu Verbringen - Einige Fonds sind bis zur Bestätigung und können nicht ausgegeben werden, doch"

Hat jemand eine Idee, warum es so lange dauert (ich vermute, es ist wegen der Größe?) und wenn es irgendetwas gibt, das ich tun kann, um die Beschleunigung der Transaktion.

+234
alfaua 10.08.2015, 05:48:42

Ich' m immer noch versuchen zu begreifen, die Konventionen, die in HD-wallets, also ich habe ein paar Fragen:

  1. Was ist der Unterschied zwischen CKDpub und CKDpriv aus der Pfad-notation. Was ich weiß, ist der Pfad nur verwendet, h oder ' , um zu Kennzeichnen, Unterschied zwischen gehärteten und nicht gehärteten dervivations aber ich sehe nicht den Unterschied zwischen einem CKDpub und CKDpriv nur durch das sehen der Weg.

  2. Aus diesem Astraleums Standardabweichung Knoten /m/44'/60'/0'/0/0 ,wie kann jemand bekommen, der erweiterte öffentliche Schlüssel und leiten die anderen öffentlichen aus, dass der extended public key Einhaltung dieser Konventionen.

  3. f(parentExtendedPubKey, index ) = childPubKey --> Adresse. Wie wird dies erreicht und wie können Sie einen privaten Schlüssel, der blieb in der HD wallet können später verwendet werden, um zu entsperren oder verbringen Sie diese Mittel, an diese Adresse gesendet, generiert durch den übergeordneten öffentlichen Schlüssel ?

+212
dcn 25.12.2011, 13:53:52

Einen lightweight-client kann nicht einmal überprüfen, für sich selbst, dass eine bestätigte Transaktion gültig ist. Es muss darauf Vertrauen, dass die Bergleute nicht verbringen Zeit der Bestätigung Ungültiger Transaktionen.

Wenn Sie ein SPV-client, und ich bin eine böse miner mit einer erheblichen Menge an mining-power, damit kann ich eine Transaktion mit einer nicht vorhandenen Eingang (im wesentlichen die Schaffung Münzen aus der Luft), und es in einem block meine ich. Dieser block wird nicht akzeptiert werden von jedem vollen Knoten, da Sie eine vollständige Transaktion registrieren und werden wissen, dass der Eingang nicht vorhanden ist, aber Ihre SPV-client akzeptieren würde. Wenn ich dann mir einige weitere Blöcke auf der Oberseite meiner falschen block, Ihre SPV-client werden denken, dass eine Transaktion hat mehrere Bestätigungen. Dies funktioniert besonders gut, wenn ich Durcheinander mit Ihrem Netzwerk-Verbindung, so dass Sie keine Verbindung zu einem full-Knoten mit Ausnahme der bösen Knoten von mir kontrolliert.

Natürlich ist dieser Angriff ziemlich teuer für mich, da ich zu verbringen mining-power, die ansonsten legitime generieren Münzen, aber vielleicht lohnt es sich, wenn ich etwas kaufen kann wertvoll für Sie und bezahlen mit gefälschten Münzen. Also, wenn Sie in das Geschäft der Verkauf von hochwertigen Gütern, Sie könnte sehr gut überlegen, es lohnt sich, einen vollen Knoten.

+149
MD Steve 05.09.2010, 03:20:44

Wenn die Versicherung für Bitcoin für Bitcoin-Verluste, welche Art von Verlusten würde der Versicherungsschutz?

+145
Hannibal Lektor 09.11.2017, 15:29:31

Ich habe einen privaten Schlüssel (raw + WIF) und ich möchten senden Sie alle Mittel aus, die-Adresse - Gebühr an eine andere Adresse.

Gibt es eine raw-python-Funktion, die können das für mich tun ? Ich übertrug den tx manuell.

Ich habe versucht, um sich in Elektron-source-code, aber ich finde es zu kompliziert für diese Aufgabe bitte um Hilfe.

+123
Djdjx 13.12.2015, 21:53:03

Diese Menschen sind in Australien ansässigen, und akzeptieren, - AUD. Sie haben auch eine Händler-service. Ich habe nicht versucht Sie noch, vielleicht, wenn der Preis sinkt wieder...

http://coinjar.io/

+87
Lubos Mudrak 14.01.2011, 03:21:42

Ich habe installiert bitcoin-core, wie die Dokumentation in bitcoin.org und seine Arbeit toll. dann habe ich versucht zu installieren bitcoin-ABC manuell wie folgt:

  1. wget bitcoin-cash-gnu.tar.gz
  2. tar xzf bitcoin-cash-gnu.tar.gz
  3. cd bitcoin-cash-gnu/bin
  4. ls

bitcoin-cli bitcoin-qt bitcoin-tx bitcoind test_bitcoin

  1. Ich habe umbenannt bin-Verzeichnis Dateien, so dass es keinen Konflikt mit bitcoin-legacy.

bitcoinCash-cli bitcoinCash-qt bitcoinCash-tx bitcoinCashd test_bitcoinCash

  1. dann habe ich es installiert auf /etc/usr/bin

sudo install-m 0755 -o root -g root -t /usr/local/bin bitcoin-cash-gnu/bin/bin/*

Dann habe ich versucht zu laufen und bitcoinCashd

Befehl nicht gefunden

+81
adipro 07.03.2016, 12:44:23

Nichts passiert. Keiner von Bitcoin Core Daten (einschließlich Ihrer wallet-Dateien, die Dateien blockieren, den block-Indizes, die chainstate, etc.) entfernt wird, wenn Bitcoin Core ist deinstalliert. Alle diese Daten werden in einem separaten Ort von der installation.

+77
IGOR911N 08.03.2012, 01:48:41

Also einfach aus der Liste coinmarketcap.com es scheint 954 cryptocurrencies jetzt. Ich vorstellen, es ist ein bisschen wie ein startup, in das die meisten von Ihnen nicht überleben.

Es ist zu spät, um mir die großen - wie die bitcoins, Astraleums und litecoins - müssen Sie wahrscheinlich gewidmet rigs mit ASIC zu meinen Sie. Aber ist es möglich, nur mir ist der kleinere? Diejenigen, die in der Anfangsphase, in der Hoffnung, dass vielleicht eines Tages werden Sie take off? Wäre es wie im Bergbau bitcoin im Jahr 2009?

+73
Sloniaka 16.10.2017, 17:01:21

Fragen mit Tag anzeigen