Lo nuevo de pares servicios segregados testigo nodos necesidad de implementar?

Lo nuevo de pares servicios segregados testigo nodos necesidad de implementar? En particular, si desea que un nodo de retransmisión tanto de un bloque, y de su testimonio de datos, ¿cómo se puede solicitar que?

+653
user1990817 31 oct. 2019 5:21:49
24 respuestas

Ayer hice mi primer Bitcoin transacción de algo físico. He comprado un par de copas en un pub.

Me fue mostrado un código QR, que recorrí con mi Blockchain.info aplicación de iPhone. Lo que me llamó la atención en la transacción fueron el minero tasas de 0.5 mBTC / 5.7 mBTC = 8.7% (mucho mayor que el 2-4% de la tarifa para las tarjetas de crédito).

Es el estándar para pagar tan alto minero honorarios por elementos físicos para agilizar la confirmación? ¿El código QR dictar el minero de la cuota que tenía que pagar, o se trataba de la aplicación para iPhone?

+987
Ohforf 03 февр. '09 в 4:24

De bitcoin.es

Cualquier equipo que se conecta a la Bitcoin red se llama un nodo. Los nodos que cumplir plenamente con todas las reglas de Bitcoin se llama full los nodos. La mayoría de los nodos en la red que son de peso ligero, los nodos en lugar de la plena los nodos, pero lleno nodos que forman la columna vertebral de la red.

Mientras usted está conectado con bitcoin red para que su equipo será considerado como bitcoin nodo.

Y para la minería piscina lamento no tener información :(

+976
Savannah Martin 30 jun. 2010 15:47:16

El Castillo Hinchable biblioteca ofrece soporte para todos los idiomas en la máquina virtual de Java

Esta biblioteca (y ahora un derivado de la biblioteca llamado Esponjoso Castillo) se utiliza en la BitCoinJ de la biblioteca.

El Castillo Hinchable biblioteca desafortunadamente fue mal implementado en Android que conducir a código de conflictos que requiere de complejas soluciones. Esponjoso Castillo resuelto los problemas para hacer el Java y Android versiones trabajo mucho más limpiamente el uno con el otro.

Hay un interesante debate sobre la elección de secp256k1 por Satoshi en los foros.

Los idiomas soportados actualmente por la JVM incluye (y cito):

  • Java
  • Clojure, funcional de un dialecto de Lisp
  • Groovy, un lenguaje de secuencias de comandos
  • Scala, orientada a objetos y lenguaje de programación funcional
  • JavaFX Script, un lenguaje de secuencias de comandos dirigidos a la Aplicación Rica de Internet de dominio (descontinuado 2010)
  • JRuby, una implementación de Ruby
  • Jython, una implementación de Python
  • Rhino, una implementación de JavaScript
  • AspectJ, un aspecto orientado a la extensión de Java
+919
upCneg 17 sept. 2017 18:02:41

La mejor manera de transferir entre los intercambios sin cargos es bitcoin.

Cupones (como mtgoxusd) solía ser muy agradable, pero ahora parece que los honorarios son a menudo acusados además de algunos de los cupones de volverse inestable.

Un arreglo en el #bitcoin-otc pueden funcionar bien a un precio bajo, pero las otc no es a menudo rápida.

Teniendo en cuenta estos dos hechos, he llegado a la conclusión de que es normalmente rápido y lo suficientemente barato como para convertir a BTC y transferencia de eso.

+824
fastestsuperman 22 sept. 2012 1:46:01

En virtud del Retiro/de la Ondulación hay un enlace llamado "confiar en esta dirección".

(quita de aquí la dirección debido a una buena sugerencia: no te fíes de lo que está escrito aquí, ir allí y echar un vistazo a ti mismo)

+777
RoyalDragonOtaku 1 oct. 2012 18:52:25

Estoy creando muchos derivados de direcciones de un xprv (HD clave privada).

He estado leyendo acerca de la brecha problema de límite. La brecha límite es de 20 direcciones por delante.

¿Cómo puedo obtener mi cartera para detectar los fondos, en las direcciones, que han superado la brecha límite?

es decir, m/100 derivados de transacciones de dirección no ser detectado, hasta que la brecha límite de llenado. Hay trucos para conseguir alrededor de esto?

Si no, pienso a granel de importación correspondiente WIF claves para cada dirección. Hacer que la gente recomienda hacer esto?

Idealmente me gustaría que todo controlable a través de la 1 de la clave maestra.

+764
marialeman 2 abr. 2015 6:01:04

Me preguntaba si alguien podría señalar mí o me dan un trabajado ejemplo de cómo OP_CHECKMULTISIG trabaja detrás de las cortinas?

Espero que CHECKMULTISIG va a llamar a la CHECKSIG función y manipular la pila para ejecutar CHECKSIG en un bucle hasta que se termina y tiene su M-out-of-N válido sigs o no?

Pero, ¿cómo funciona exactamente? E. g. 2-de-3 multisig. Si tenemos OP_0 (sig1) (sig2) en el scriptSig, a continuación, la pila se verá así:

  • (sig2)
  • (sig1)
  • 0

Ahora, a partir de la forma general de la escritura CHECKMULTISIG en el scriptPubKey: 2 (pubKey1) (pubKey2) (pubKey3) 3 OP_CHECKMULTISIG, empujando a todos los datos en la pila, la pila para el scriptPubKey se verá así:

  • 3
  • (pubKey3)
  • (pubKey2)
  • (pubKey1)
  • 2

¿Cuál será el primer paso de CHECKMULTISIG?

Va a meter el "3" de la pila y, a continuación, tal vez comprobar si hay tres pubKeys en la pila?

O será sólo aparecerá el "3" y, a continuación, ejecutar inmediatamente CHECKSIG en (sig2) y (pubKey3), que no será válido, por lo tanto CHECKSIG empujará un "0" en la pila?

Entonces CHECKMULTISIG quitar el "0" que CHECKSIG introducido en la pila y vuelva a intentar con (sig2) y (pubKey2)? Ya que esto es válido CHECKSIG empujará un "1" en la pila, pero, ¿de dónde CHECKMULTISIG tienda de este "1"?

Y CHECKMULTISIG al final la cuenta de cuantas "1"'s CHECKSIG, y este número debe corresponder al último valor de la pila, en este caso "2", pero en general "M"?

Realmente me gustaría encontrar un bajo nivel de descripción de CHECKMULTISIG, de manera similar a la que se podría encontrar para CHECKSIG: https://en.bitcoin.it/wiki/OP_CHECKSIG

Cualquier ayuda sería muy apreciada!

+740
Preston Alexander 25 dic. 2015 17:32:38

Comando

nslookup semilla.bitcoin.sipa.ser

da una lista de 40 nodos.

1) ¿Bitcoin wallet tomar todos los nodos de la lista?

o

2) ¿Bitcoin wallet se comportan como aplicación normal que se resuelve la semilla.bitcoin.sipa.ser y tomar sólo una dirección IP para conectarse.

+735
Xeijp 8 may. 2010 19:54:56

He estado leyendo acerca de la transacción de maleabilidad mucho aún así no tiene sentido para mí. Hay una secuencia de comandos que puede utilizar para probarlo ? Si la transacción que es maleable es cambiado por el ataque, ¿cómo es posible que las dos transacciones están todavía en el blockchain y los mineros todavía recoger los atacantes TXID sobre la legítima? ¿Por qué nuestros legítimos de la transacción no es visto por los mineros?

+657
vitekfar 11 mar. 2011 11:36:51

He estado corriendo en problemas con un alto tráfico caliente cartera, donde una sola transacción llave de entrada para un bloque con el spendzeroconfchange movilidad.

Sería seguro para un servicio como Coinbase para uso sin confirmar entradas, en promedio, las transacciones? Si me presentaría en problemas similares como MtGox hizo?

+643
Bakinbutty 17 jun. 2012 14:36:43

Yo estaba pensando en comprar el Monarca BPU 300 C o 600 C. Sin embargo, ninguno de ellos se espera que la nave antes de febrero de 2014 o más tarde.

Si esta calculadora se puede confiar, que no parece que uno nunca podría ganar de nuevo el costo de cualquiera de estas unidades, especialmente si esta dificultad gráfico es exacta.

Según dijo la calculadora, el 600 modelo dejarían de $2000 a corto después de 6 meses a un precio de compra de $4680. También, los más baratos de 300 modelo saldría alrededor de $1450 corto después de 6 meses después de que un precio de compra de $2800. Y esas cifras son suponiendo que usted comience a usar el producto a mediados de febrero. Si la Mariposa de los laboratorios de retraso en el envío de las cartas, y lo que empieza en Marzo... olvidarse de él.

Soy bastante nuevo en el Bitcoin juego, así que puede que alguien me diga si estoy equivocado acerca de esto? Es realmente conveniente para comprar cualquiera de estas tarjetas?

Edición - La respuesta corta es NO, especialmente para SHA-256 monedas. Pasé alrededor de $1000 en un 50 GH/s miner. Se generó alrededor de $30 por semana en la utilidad bruta, pero la ganancia neta fue de menos debido a la piscina honorarios. También, mi factura de electricidad aumentó en $100 por mes. Por suerte, yo era capaz de encontrar a alguien para comprar el minero de mí en ebay por CERCA de lo que pagó por él.

+640
Nailbudday 22 may. 2014 11:21:43

La vulnerabilidad afecta a la codificación de la cartera de archivo, el debilitamiento de la encriptación mediante la reducción de los recursos necesarios para ataque de fuerza bruta es.

Prácticamente, esto significa que si un atacante para obtener una copia de su cartera.archivo dat, que podría tener un tiempo más fácil la fuerza bruta de ataque (es decir. adivinar la contraseña sería un poco más fácil), en comparación con un ataque en contra de una cartera.dat archivo utilizando la misma contraseña, que no es afectado por la vulnerabilidad.

Cualquier ataque que explota esta vulnerabilidad tiene que ser muy específica, por lo que para los usuarios afectados la amenaza de ataque es probablemente muy baja. Tal vez irónicamente, pidiendo ayuda, puede llamar la atención a sí mismo como un usuario afectado, entonces yo sería muy cuidadoso de cualquier persona que ofrece una "herramienta" para ayudar a solucionar el problema!

Supongo que aquí el objetivo es simplemente para asegurarse de que su bitcoins son seguras. Si usted está preocupado de que alguien pueda robar (de tener ya el robo de su cartera cifrada.archivo dat, una solución sencilla sería la de crear una nueva cartera utilizar el software de su elección y, a continuación, enviar la totalidad del saldo de la cartera a la nueva. De esta manera, su nueva cartera de archivo no será afectado por la vulnerabilidad.

+633
cento 21 nov. 2014 20:22:10

Sé cómo programar en C++, pero no sé realmente cómo todo el sistema de minería de obras. Tengo mi altcoin, y me gustaría bloque recompensa bloques a los mineros que no son authentified (algo clave privada o de Cartera de la Dirección). Me gustaría que los mineros generar bloques y monedas, pero no quiero que ellos lo tienen, todas las monedas minadas para nada sería enviado a un maestro de la cartera o se ha perdido para siempre. Pero, si un minero ha generado monedas y él es authentificated y autorizado para generar moneda, iba a llegar a ellos.

Para ponerlo simple, solo quiero bloque de la moneda de la generación de capacidad para todos. He pensado que pudiera detener la ejecución de un hilo para la minería, pero se podría modificar el cliente y volver a iniciarlo. Así que me preguntaba ¿cómo puede yo puedo hacer eso, me he leído el código sobre CheckWork, ProcessBlock, etc... Pero no puedo entenderlo completamente.

Gracias de antemano por su ayuda.

+591
slon1 24 jun. 2016 3:16:53

Un bloque deben satisfacer las siguientes condiciones para que sea válido:

  • El tamaño total del bloque debe ser de 1 mb o menos.
  • Al menos 1 operación llamada la coinbase transacción debe existir.
  • Bloque debe satisfacer la prueba-de-trabajo.
  • Bloque debe hacer referencia a un válido bloque en el bloque anterior.

Hay algunos misceláneos restricciones, pero estos son los principales. Lo que usted llama "resuelto por la minería" es lo que se llama la satisfacción de la prueba-de-trabajo. Lo que usted llama tener al menos una transacción es la restricción de que el coinbase transacción debe estar presente. Os animo a leer la especificación para averiguar más.

+506
Waleed Rahman 31 oct. 2017 11:24:14

Como un usuario de bitcoin, es conveniente ejecutar un completo nodo, ya que permite de forma independiente validar el estado actual de la red usted mismo, sin tener que confiar en las acciones o de un tercero. El usuario no recibe ninguna recompensa monetaria, sino la capacidad para trustlessly interactuar con el bitcoin red es una característica muy importante, que es muy central para cualquier descentralizado cryptocurrency de la red.

Como un Ápice de usuario, usted no puede alcanzar el mismo nivel de trustless interacción. Como yo lo entiendo, Iota emplea un 'coordinador de nodo", que básicamente tiene los derechos de administrador a la red, por lo que debe confiar en que el coordinador no va a actuar maliciosamente, o ser de otra manera comprometida. Puede ejecutar un nodo para verificar las transacciones de ti mismo, pero si el coordinador decide congelar sus monedas, tener un nodo no le ayudará.

Así que yo no estaría de acuerdo con la comparación, o al menos yo diría que no es una buena línea de razonamiento. El nivel de trustless interacción que se habilita mediante la ejecución de un nodo bitcoin simplemente no es posible lograr en Iota debido a la existencia de la centralización de la posición de coordinador.

+396
alfshort 17 jun. 2010 16:06:29

Primera: yo soy un newbite a altcoin desarrollo, junto a generar una altcoin de litecoin,
1 - he hecho un clon de litecoin el uso de git clone https://githubcom/litecoin-project/lotecoin.git
2 - he cambiado algunos de de la cadena de monedas y de los parámetros en chainparams.cpp como a continuación:

// Copyright (c) 2010 Satoshi Nakamoto
 // Copyright (c) 2009-2015 El Bitcoin Core desarrolladores
 // Distribuido bajo el MIT de licencia de software, ver el adjunto
 // archivo de COPIA o http://www.opensource.org/licenses/mit-license.php.

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

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

 #include <assert.h>

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

 estática CBlock CreateGenesisBlock(const char* pszTimestamp, const CScript& genesisOutputScript, uint32_t nTime, uint32_t nNonce, uint32_t nBits, int32_t nVersion, const CAmount& genesisReward)
{
 CMutableTransaction txNew;
 txNew.nVersion = 1;
txNew.vin.cambiar el tamaño de(1);
txNew.vsal.cambiar el tamaño de(1);
 txNew.vin[0].scriptSig = CScript() << 486604799 << CScriptNum(4) << std::vector<unsigned char>((const unsigned char*)pszTimestamp, (const unsigned char*)pszTimestamp + strlen(pszTimestamp));
 txNew.uout[0].nvalor = genesisReward;
 txNew.uout[0].scriptPubKey = genesisOutputScript;

 CBlock génesis;
 el génesis.nTime = nTime;
 el génesis.nBits = nBits;
 el génesis.nNonce = nNonce;
 el génesis.nVersion = nVersion;
el génesis.vtx.push_back(MakeTransactionRef(std::move(txNew)));
el génesis.hashPrevBlock.SetNull();
 el génesis.hashMerkleRoot = BlockMerkleRoot(génesis);
 volver génesis;
}

/**
 * Construir la génesis de bloque. Tenga en cuenta que la salida de su generación
 * transacción no se pueden gastar, ya que no fueron originalmente existen en el
 * la base de datos.
*
 * CBlock(hash=000000000019d6, ver=1, hashPrevBlock=00000000000000, hashMerkleRoot=4a5e1e, nTime=1231006505, nBits=1d00ffff, *nNonce=2083236893, vtx=1)
 * CTransaction(hash=4a5e1e, ver=1, vin.size=1, vsal.size=1, nLockTime=0)
 * CTxIn(COutPoint(000000, -1), coinbase *04ffff001d0104455468652054696d65732030332f4a616e2f32303039204368616e63656c6c6f72206f6e206272696e6b206f66207365636f6e64206261696c6f757420**666f722062616e6b73)
 * CTxOut(nvalor=50.00000000, scriptPubKey=0x5F1DF16B2B704C8A578D0B)
 * vMerkleTree: 4a5e1e
*/

 estática CBlock CreateGenesisBlock(uint32_t nTime, uint32_t nNonce, uint32_t nBits, int32_t nVersion, const CAmount& genesisReward)
{
 const char* pszTimestamp = "Tehran Times, Stonica gana finalmente";
 const CScript genesisOutputScript = CScript() << ParseHex("040184710fa689ad5023690c80f3a49c8f13f8d45b8c857fbcbc8bc4a8e4d3eb4b10f4d4604fa08dce601aaf0f470216fe1b51850b4acf21b179c45070ac7b03a9") << OP_CHECKSIG;
 volver CreateGenesisBlock(pszTimestamp, genesisOutputScript, nTime, nNonce, nBits, nVersion, genesisReward);
}

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

/**
 * Red principal
*/
/**
 * ¿Qué hace a un buen puesto de control de bloque?
 * + Está rodeado por bloques con marcas de tiempo razonable
 * (no hay bloques antes con una marca de hora después, ninguno después con
 * marca de hora antes)
 * + No contiene extraño transacciones
*/

 clase CMainParams : público CChainParams {
público:
 CMainParams() {
 strNetworkID = "principal";
 consenso.nSubsidyHalvingInterval = 840000;
 consenso.BIP34Height = 710000;
 consenso.BIP34Hash = uint256S("00000000b2c50d03d4d0bdd38681775ce522f137518145d6b3c913b7dd4423e5");
 consenso.BIP65Height = 918684; // bab3041e8977e0dc3eeff63fe707b92bde1dd449d8efafb248c27c8264cc311a
 consenso.BIP66Height = 811879; // 7aceee012833fa8952f8835d8b1b3ae233cd6ab08fdb27a771d2bd7bdc491894
 consenso.powLimit = uint256S("00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"); 
 consenso.nPowTargetTimespan = 3.5 * 24 * 60 * 60; // 3.5 días
 consenso.nPowTargetSpacing = 2.5 * 60;
 consenso.fPowAllowMinDifficultyBlocks = false;
 consenso.fPowNoRetargeting = false;
 consenso.nRuleChangeActivationThreshold = 6048; // el 75% de 8064
 consenso.nMinerConfirmationWindow = 8064; // nPowTargetTimespan / nPowTargetSpacing * 4
 consenso.vDeployments[Consenso::DEPLOYMENT_TESTDUMMY].bit = 28;
 consenso.vDeployments[Consenso::DEPLOYMENT_TESTDUMMY].nStartTime = 1199145601; // 1 de enero de 2008
 consenso.vDeployments[Consenso::DEPLOYMENT_TESTDUMMY].nTimeout = 1230767999; // el 31 de diciembre de 2008

 // Implementación de BIP68, BIP112, y BIP113.
 consenso.vDeployments[Consenso::DEPLOYMENT_CSV].bit = 0;
 consenso.vDeployments[Consenso::DEPLOYMENT_CSV].nStartTime = 1485561600; // el 28 de enero de 2017
 consenso.vDeployments[Consenso::DEPLOYMENT_CSV].nTimeout = 1517356801; // el 31 de enero de 2018

 // Implementación de SegWit (BIP141, BIP143, y BIP147)
 consenso.vDeployments[Consenso::DEPLOYMENT_SEGWIT].bit = 1;
 consenso.vDeployments[Consenso::DEPLOYMENT_SEGWIT].nStartTime = 1485561600; // el 28 de enero de 2017
 consenso.vDeployments[Consenso::DEPLOYMENT_SEGWIT].nTimeout = 1517356801; // el 31 de enero de 2018

 // La mejor cadena debe tener al menos este trabajo.
 consenso.nMinimumChainWork = uint256S("0x00000000000000000000000000000000000000000000000ba50a60f8b56c7fe0");

 // Por defecto asume que las firmas que aparecen en los antepasados de este bloque son válidos.
 consenso.defaultAssumeValid = uint256S("0x29c8c00e1a5f446a6364a29633d3f1ee16428d87c8d3851a1c570be8170b04c2"); //1259849

/**
 * El mensaje de inicio de cadena está diseñado para ser poco probable que se produzca en los datos normales.
 * Los personajes son raramente utilizados ASCII superior, no es válido como UTF-8, y producir
 * un gran valor entero de 32 bits con cualquier alineación.
*/
 pchMessageStart[0] = 0x0b;
 pchMessageStart[1] = 0xd0;
 pchMessageStart[2] = 0xb6;
 pchMessageStart[3] = 0xdb;
 nDefaultPort = 9335;
 nPruneAfterHeight = 100000;
 //static CBlock CreateGenesisBlock(uint32_t nTime, uint32_t nNonce, uint32_t nBits, int32_t nVersion, const CAmount& genesisReward)
 génesis = CreateGenesisBlock(1511279793, 1251189192, 0x1d00ffff , 1, 50 * de la MONEDA);
 consenso.hashGenesisBlock = génesis.GetHash();

 /* 
 // calcular la Génesis de Bloque
 // Reset génesis
 consenso.hashGenesisBlock = uint256S("0");
 std::cout << std::string("Empezar a calcular Mainnet Génesis Bloque:\n");
 si (true && (génesis.GetHash() != consenso.hashGenesisBlock)) {
 LogPrintf("Cálculo de Mainnet Génesis Bloque:\n");
 arith_uint256 hashTarget = arith_uint256().SetCompact(génesis.nBits);
 uint256 hash;
 el génesis.nNonce = 0;
 // Esto va a averiguar un hash válido y Nonce si usted está
 // creación de diferentes génesis bloque:
 // uint256 hashTarget = CBigNum().SetCompact(génesis.nBits).getuint256();
 // hashTarget.SetCompact(génesis.nBits, &fNegative, &fOverflow).getuint256();
 // mientras (génesis.GetHash() > hashTarget)
 mientras (UintToArith256(génesis.GetHash()) > hashTarget)
{
++génesis.nNonce;
 si (génesis.nNonce == 0)
{
 LogPrintf("NONCE ENVUELTO, el incremento de tiempo");
 std::cout << std::string("NONCE ENVUELTO, el incremento de tiempo:\n");
++génesis.nTime;
}
 si (génesis.nNonce % 10000 == 0)
{
 LogPrintf("Mainnet: nonce %08u: hash = %s \n", génesis.nNonce, génesis.GetHash().ToString().c_str());
 // std::cout << strNetworkID << "nonce:" << génesis.nNonce << "tiempo:" << génesis.nTime << "hash:" << génesis.GetHash().ToString().c_str() << "\n";
}
}
 std::cout << "Mainnet ---\n";
 std::cout << "nonce:" << génesis.nNonce << "\n";
 std::cout << "tiempo:" << génesis.nTime << "\n";
 std::cout << "hash:" << génesis.GetHash().ToString().c_str() << "\n";
 std::cout << "merklehash:" << génesis.hashMerkleRoot.ToString().c_str() << "\n";
 // Mainnet --- nonce: 296277 tiempo: 1390095618 hash: 000000bdd771b14e5a031806292305e563956ce2584278de414d9965f6ab54b0
}
 std::cout << std::string("Terminado de calcular Mainnet Génesis Bloque:\n");


*/





//printf("%s\n",de consenso.hashGenesisBlock.Tostring().c_str());
 std::cout << std::string("ESCRIBA:\n");
 assert(consenso.hashGenesisBlock == uint256S("0x00000000b2c50d03d4d0bdd38681775ce522f137518145d6b3c913b7dd4423e5"));
 assert(génesis.hashMerkleRoot == uint256S("0xf8621e34b0dcd43361fe589702e06aa79992229bfbca57d058d8561635c30fbe"));
 std::cout << std::string("PASADO:\n");

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

 // Tenga en cuenta que de esos con el servicio de bits de la bandera, la mayoría sólo admiten un subconjunto de las posibles opciones
 //vSeeds.emplace_back("la semilla de una.stonicacoin.loshan.co.reino unido", 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);
 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{
 // Datos de bloque de db42d00d824950a125f9b08b6b6c282c484781562fa8b3bd29d6ce4a2627c348 (altura 1259851).
 1502955334, // * UNIX timestamp de la última conocida en número de transacciones
 1, // * número total de transacciones entre el génesis y que timestamp
 // (el tx=... número en el SetBestChain de depuración.las líneas de registro)
 0.00 // * se estima que el número de transacciones por segundo después de que la marca de tiempo
};
}
};

/**
 * Testnet (v3)
*/
 clase CTestNetParams : público CChainParams {
público:
 CTestNetParams() {
 strNetworkID = "prueba";
 consenso.nSubsidyHalvingInterval = 840000;
 consenso.BIP34Height = 76;
 consenso.BIP34Hash = uint256S("8075c771ed8b495ffd943980a95f702ab34fce3c8c54e379548bda33cc8c0573");
 consenso.BIP65Height = 76; // 8075c771ed8b495ffd943980a95f702ab34fce3c8c54e379548bda33cc8c0573
 consenso.BIP66Height = 76; // 8075c771ed8b495ffd943980a95f702ab34fce3c8c54e379548bda33cc8c0573
 consenso.powLimit = uint256S("00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
 consenso.nPowTargetTimespan = 3.5 * 24 * 60 * 60; // 3.5 días
 consenso.nPowTargetSpacing = 2.5 * 60;
 consenso.fPowAllowMinDifficultyBlocks = true;
 consenso.fPowNoRetargeting = false;
 consenso.nRuleChangeActivationThreshold = 1512; // el 75% de testchains
 consenso.nMinerConfirmationWindow = 2016; // nPowTargetTimespan / nPowTargetSpacing
 consenso.vDeployments[Consenso::DEPLOYMENT_TESTDUMMY].bit = 28;
 consenso.vDeployments[Consenso::DEPLOYMENT_TESTDUMMY].nStartTime = 1199145601; // 1 de enero de 2008
 consenso.vDeployments[Consenso::DEPLOYMENT_TESTDUMMY].nTimeout = 1230767999; // el 31 de diciembre de 2008

 // Implementación de BIP68, BIP112, y BIP113.
 consenso.vDeployments[Consenso::DEPLOYMENT_CSV].bit = 0;
 consenso.vDeployments[Consenso::DEPLOYMENT_CSV].nStartTime = 1483228800; // 1 de enero de 2017
 consenso.vDeployments[Consenso::DEPLOYMENT_CSV].nTimeout = 1517356801; // el 31 de enero de 2018

 // Implementación de SegWit (BIP141, BIP143, y BIP147)
 consenso.vDeployments[Consenso::DEPLOYMENT_SEGWIT].bit = 1;
 consenso.vDeployments[Consenso::DEPLOYMENT_SEGWIT].nStartTime = 1483228800; // 1 de enero de 2017
 consenso.vDeployments[Consenso::DEPLOYMENT_SEGWIT].nTimeout = 1517356801; // el 31 de enero de 2018

 // La mejor cadena debe tener al menos este trabajo.
 consenso.nMinimumChainWork = uint256S("0x0000000000000000000000000000000000000000000000000000364b0cbc3568");

 // Por defecto asume que las firmas que aparecen en los antepasados de este bloque son válidos.
 consenso.defaultAssumeValid = uint256S("0xad8ff6c2f5580d2b50bd881e11312425ea84fa99f322bf132beb722f97971bba"); //153490

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

 génesis = CreateGenesisBlock(1511279793, 0, 0x1d00ffff , 1, 50 * de la MONEDA);
 consenso.hashGenesisBlock = génesis.GetHash();
 //assert(consenso.hashGenesisBlock == uint256S("0"));
 //assert(génesis.hashMerkleRoot == uint256S("0"));

vFixedSeeds.clear();
vSeeds.clear();
 // nodos con soporte para servicebits filtrado debe ser en la parte superior
 //vSeeds.emplace_back("testnet-seed.stonicacointools.com", true);
 //vSeeds.emplace_back("la semilla b.stonicacoin.loshan.co.reino unido", 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, 0 x 87, 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{
 // Datos de bloque de 3351b6229da00b47ad7a8d7e1323b0e2874744b5296e3d6448293463ab758624 (altura 153489)
//1502953751,
//382986,
//0.01
};

}
};

/**
 * Pruebas de regresión
*/
 clase CRegTestParams : público CChainParams {
público:
 CRegTestParams() {
 strNetworkID = "regtest";
 consenso.nSubsidyHalvingInterval = 150;
 consenso.BIP34Height = 100000000; // BIP34 no ha activado en regtest (en el futuro lejano para bloquear la v1 no son rechazados en las pruebas)
 consenso.BIP34Hash = uint256();
 consenso.BIP65Height = 1351; // BIP65 activado en regtest (Utilizado en la rpc de la activación de las pruebas)
 consenso.BIP66Height = 1251; // BIP66 activado en regtest (Utilizado en la rpc de la activación de las pruebas)
 consenso.powLimit = uint256S("7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
 consenso.nPowTargetTimespan = 3.5 * 24 * 60 * 60; // dos semanas
 consenso.nPowTargetSpacing = 2.5 * 60;
 consenso.fPowAllowMinDifficultyBlocks = true;
 consenso.fPowNoRetargeting = true;
 consenso.nRuleChangeActivationThreshold = 108; // el 75% de testchains
 consenso.nMinerConfirmationWindow = 144; // más Rápido de lo normal para regtest (144 en lugar de 2016)
 consenso.vDeployments[Consenso::DEPLOYMENT_TESTDUMMY].bit = 28;
 consenso.vDeployments[Consenso::DEPLOYMENT_TESTDUMMY].nStartTime = 0;
 consenso.vDeployments[Consenso::DEPLOYMENT_TESTDUMMY].nTimeout = 999999999999ULL;
 consenso.vDeployments[Consenso::DEPLOYMENT_CSV].bit = 0;
 consenso.vDeployments[Consenso::DEPLOYMENT_CSV].nStartTime = 0;
 consenso.vDeployments[Consenso::DEPLOYMENT_CSV].nTimeout = 999999999999ULL;
 consenso.vDeployments[Consenso::DEPLOYMENT_SEGWIT].bit = 1;
 consenso.vDeployments[Consenso::DEPLOYMENT_SEGWIT].nStartTime = 0;
 consenso.vDeployments[Consenso::DEPLOYMENT_SEGWIT].nTimeout = 999999999999ULL;

 // La mejor cadena debe tener al menos este trabajo.
 consenso.nMinimumChainWork = uint256S("0x00");

 // Por defecto asume que las firmas que aparecen en los antepasados de este bloque son válidos.
 consenso.defaultAssumeValid = uint256S("0x00");

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

 génesis = CreateGenesisBlock(1511279793, 0, 0x1d00ffff , 1, 50 * de la MONEDA);
 consenso.hashGenesisBlock = génesis.GetHash();
 assert(consenso.hashGenesisBlock == uint256S("0x9"));
 assert(génesis.hashMerkleRoot == uint256S("0"));

 vFixedSeeds.clear(); //!< Regtest modo no tiene ningún fija semillas.
 vSeeds.clear(); //!< Regtest modo no tiene ningún DNS semillas.

 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, 0 x 87, 0xCF};
 base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94};
}
};

 estática std::unique_ptr<CChainParams> globalChainParams;

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

 std::unique_ptr<CChainParams> CreateChainParams(const std::string& cadena)
{
 if (cadena == CBaseChainParams::main (PRINCIPAL)
 volver std::unique_ptr<CChainParams>(nueva CMainParams());
 else if (cadena == CBaseChainParams::TESTNET)
 volver std::unique_ptr<CChainParams>(nueva CTestNetParams());
 else if (cadena == CBaseChainParams::REGTEST)
 volver std::unique_ptr<CChainParams>(nueva CRegTestParams());
 tirar std::runtime_error(strprintf("%s: Desconocido cadena %s.", __func__, de la cadena));
}

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

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

Como usted puede saber el bitcoin desarrolladores ha omitido la génesis del bloque de código de minería, a partir del código fuente publicado en github, pero que, afortunadamente, se encontró un fragmento de código en blogs relacionados y funcionó, a continuación, he calculado el nuevo Génesis hash, Merkelroot hash y Nonce y poner en el código como se puede ver arriba. El código fue compilado correctamente y no he recibido error de Aserción mensaje para la Génesis de bloque, pero he recibido otro error que se puede ver en la depuración.registro de la siguiente manera:

 2017-12-15 07:31:33 



















 2017-12-15 07:31:33 Stonicacoin versión v0.15.0.1-gba8ed3a93be
 2017-12-15 07:31:33 InitParameterInteraction: parámetro de interacción: -whitelistforcerelay=1 -> configuración -whitelistrelay=1
 2017-12-15 07:31:33 Suponiendo que los antepasados de bloque 29c8c00e1a5f446a6364a29633d3f1ee16428d87c8d3851a1c570be8170b04c2 han firmas válidas.
 2017-12-15 07:31:33 a través de la 'norma' SHA256 aplicación
 2017-12-15 07:31:33 Uso de RdRand como un adicional de entropía de la fuente
 2017-12-15 07:31:33 datos por Defecto el directorio /home/kevin/.stonicacoin
 2017-12-15 07:31:33 Uso de los datos del directorio /home/kevin/.stonicacoin
 2017-12-15 07:31:33 desde el archivo config /home/kevin/.stonicacoin/stonicacoin.conf
 2017-12-15 07:31:33 Uso en la mayoría de los 125 conexiones automáticas (1024 descriptores de archivo disponible)
 2017-12-15 07:31:33 16 MiB de 32/2 solicitado para el caché de la firma, capaz de almacenar 524288 elementos
 2017-12-15 07:31:33 16 MiB de 32/2 solicitados para la ejecución de secuencias de comandos de caché, capaz de almacenar 524288 elementos
 2017-12-15 07:31:33 con 8 hilos de la secuencia de comandos de verificación
 2017-12-15 07:31:33 subproceso de programador de inicio
 2017-12-15 07:31:33 HTTP: creación de la cola de trabajos de profundidad de 16
 2017-12-15 07:31:33 No rpcpassword establecer - mediante un sistema aleatorio de cookie de autenticación
 2017-12-15 07:31:33 Generado RPC cookie de autenticación /home/kevin/.stonicacoin/.cookie
 2017-12-15 07:31:33 HTTP: a partir del 4 de subprocesos de trabajo
 2017-12-15 07:31:33 configuración de Caché:
 2017-12-15 07:31:33 * el Uso de 2.0 MiB para bloquear el índice de la base de datos
 2017-12-15 07:31:33 * el Uso de 8.0 MiB para la cadena de base de datos de estado
 2017-12-15 07:31:33 * el Uso de 440.0 MiB para en-memoria UTXO conjunto (además de hasta 4.8 MiB de los mempool espacio)
 2017-12-15 07:31:33 init mensaje: Carga de índice del bloque de...
 2017-12-15 07:31:33 Apertura LevelDB en /home/kevin/.stonicacoin/bloques/índice
 2017-12-15 07:31:33 Abrió LevelDB con éxito
 2017-12-15 07:31:33 Uso de ofuscación clave para /home/kevin/.stonicacoin/bloques/índice: 0000000000000000
 2017-12-15 07:31:33 LoadBlockIndexDB: último bloque del archivo = 0
 2017-12-15 07:31:33 LoadBlockIndexDB: el último bloque de información de archivo: CBlockFileInfo(bloques=0, size=0, altura=0...0, tiempo=1970-01-01...1970-01-01)
 2017-12-15 07:31:33 Comprobación de todos los blk archivos están presentes...
 2017-12-15 07:31:33 LoadBlockIndexDB: transacción índice de movilidad
 2017-12-15 07:31:33 Inicialización de las bases de datos de...
 2017-12-15 07:31:33 Pre-asignar a la posición 0x1000000 en blk00000.dat
 2017-12-15 07:31:33 Apertura LevelDB en /home/kevin/.stonicacoin/chainstate
 2017-12-15 07:31:33 Abrió LevelDB con éxito
 2017-12-15 07:31:33 Escribió una nueva ofuscar clave para /home/kevin/.stonicacoin/chainstate: 77f259e28117a4e1
 2017-12-15 07:31:33 Uso de ofuscación clave para /home/kevin/.stonicacoin/chainstate: 77f259e28117a4e1
 2017-12-15 07:31:33 init mensaje: Rebobinado de bloques de...
 2017-12-15 07:31:33 índice del bloque de 11 ms
 2017-12-15 07:31:33 No hay billetera sido compilado con soporte!
 2017-12-15 07:31:33 ERROR: ReadBlockFromDisk: Errores en el encabezado de bloque en CBlockDiskPos(nFile=0, nPos=8)
 2017-12-15 07:31:33 *** no se pudo leer el bloque de
 2017-12-15 07:31:33 Error: Error: fatal error interno, consulte la depuración.registro para obtener más detalles

He encontrado que este error(por ejemplo. ERROR: ReadBlockFromDisk: Errores en el encabezado de bloque en CBlockDiskPos(nFile=0, nPos=8) ) se producen en CheckProofOfWork función que está en pow.cpp Cualquier recomendación es apreciado.

+363
dtaebert 7 may. 2018 3:49:04

Se puede comprobar la temperatura de los dispositivos, el activo debe estar en ejecución mucho más caliente que los otros.

Si todos están ejecutando en caliente en el cuello de botella está en otra parte (de la CPU o de memoria/ancho de banda). Si ninguno de ellos se están ejecutando caliente que te has comprado un infierno de una CPU para obtener 200Mhash.

Otra cosa es aconsejable comprobar si se puede o no utilizar la no-defecto de la tarjeta de video en todo.

Me temo que me falta el videocards a prueba a mí mismo :)

+284
MyMacPro 13 nov. 2011 19:37:19

Usted puede encontrar otro bloqueador.io litecoin bloque explorer para alt moneda.

Bockr.io Litecoin bloque explorer

+189
Pyae Phyo Kyaw 14 ago. 2015 3:09:58

Los datos de la transacción se ve bien. vsal tiene un valor de .001 y le están saliendo .0001 por un suplemento. Tal vez no firmar correctamente :)

bitcoin-cli decoderawtransaction 010000000180692cc54f9082c00a718123539396c42fd1a6d4a77eef677030483ce79fd3e70100000000ffffffff02b0040000000000001976a914817b776c02b9e0fe60163a170b0d72a194a463ef88ace05a0100000000001976a914817b776c02b9e0fe60163a170b0d72a194a463ef88ac00000000

{
 "txid": "16ee12e50d1ff805e91f34ab313d30009943c703fb142e9f457e0ea96a404e09",
 "tamaño": 119,
 "versión": 1,
 "locktime": 0,
 "vin": [
{
 "txid": "e7d39fe73c48307067ef7ea7d4a6d12fc49693532381710ac082904fc52c6980",
 "vsal": 1,
 "scriptSig": {
 "asm": "",
 "hex": ""
},
 "secuencia": 4294967295
}
],
 "vsal": [
{
 "valor": 0.00001200,
 "n": 0,
 "scriptPubKey": {
 "asm": "OP_DUP OP_HASH160 817b776c02b9e0fe60163a170b0d72a194a463ef OP_EQUALVERIFY OP_CHECKSIG",
 "hex": "76a914817b776c02b9e0fe60163a170b0d72a194a463ef88ac",
 "reqSigs": 1,
 "tipo": "pubkeyhash",
 "direcciones": [
"msKbNQHuJoAdK4AKCof6ahoxzBsKG36Uye"
]
}
},
{
 "valor": 0.00088800,
 "n": 1,
 "scriptPubKey": {
 "asm": "OP_DUP OP_HASH160 817b776c02b9e0fe60163a170b0d72a194a463ef OP_EQUALVERIFY OP_CHECKSIG",
 "hex": "76a914817b776c02b9e0fe60163a170b0d72a194a463ef88ac",
 "reqSigs": 1,
 "tipo": "pubkeyhash",
 "direcciones": [
"msKbNQHuJoAdK4AKCof6ahoxzBsKG36Uye"
]
}
}
]
}
+142
voco 4 feb. 2015 2:10:03

Supongo que cuando te refieres a "terceros" vigilantes que significa torres de vigilancia. Estoy de acuerdo en que 'trustless' es probablemente un término ambiguo en este contexto. En el momento de la escritura, la única propuesta real con un protocolo que soy consciente es de PISA, por Andrew Miller et al. PISA permite a los usuarios seleccionar un tutor que será incentivada en la publicación. Los usuarios pagan el custodio, y el custodio pierde fondos si no se realizan (es decir, si la entidad de contrapartida nodo se las arregla para publicar un viejo estado).

Por el momento, parece que Roger Wattenhofer está trabajando en ello demasiado. Sin embargo, no han propuesto un protocolo todavía. Su idea es incentivar a través de recompensas cuando los canales son de 'salvados', en lugar de a través de penalización cuando la watchtower no ahorrar en el tiempo.

Ambos lados tienen pros y contras.

  • La estafa de Miller propuesta es que uno debe elegir la atalaya, tener que confiar en él. La contraparte podría intentar sobornar a la watchtower, de modo que ambos ganan más de las penas.

  • Wattenhofer la propuesta no tiene este problema, como cualquier persona en la red puede recuperar la recompensa, y por lo tanto todo el mundo es el de la atalaya. El problema de esta propuesta es que no hay incentivos para que la gente ataque a otras personas y les impiden la publicación de sí mismos.

Este es un trabajo en progreso. Como un auto-afirmó trustless de la watchtower, ha habido un cierto debate en la ligthing-dev lista de correo aquí y aquí, pero es todavía un trabajo en progreso.

+96
Linda Hutchinson 11 feb. 2018 9:50:05

Usted puede tomar un vistazo a whattomine.com y decidir qué mina dependiendo de la tasa de hash eres capaz de salir de su máquina. Sugerencia: BTC es probable que no te va a funcionar para usted.

Tenga en cuenta, sin embargo, no todos los ASICs pueden minar todas las monedas. Usted necesita decidir lo que usted desea a la mía, y entonces usted puede comenzar a buscar el hardware adecuado.

+84
Karma Dolma 13 jul. 2018 3:41:33

Un amigo me envió Bitcoin a mi monedero de blockchain. Muestra la cantidad como parte de mi equilibrio. Sin embargo, dice que hay 108 confirmaciones y el número de confirmaciones que sigue subiendo. ¿Por qué está sucediendo esto? Puedo pasar este Bitcoin, mientras que las confirmaciones de continuar?

+70
triki 1 mar. 2017 13:53:14

estoy tratando de convertir a los

URI en BIP21

actualmente estoy generando URI de bitcoinj de la biblioteca, pero quiero que sea en BIP21 Estándar. he leído muchos artículos, pero no encontró ninguna solución

+65
Andrey Khmelevskiy 11 jul. 2012 9:11:11

Creo que no es posible. Todavía están trabajando en ello.

https://github.com/lightningnetwork/lnd/issues/732

+25
tamale 10 ago. 2018 21:45:12

Mostrar preguntas con etiqueta