Jeton d'authentification d'erreur de manipulation

Est-il un site où je peux voir la taille du pool de mémoire au fil du temps, ou le nombre moyen de transactions par bloc?

Où puis-je vérifier combien l'ASIC, l'exploitation minière, le pouvoir a été livré, ce qui a été pré-commandés, quand il sera livré, et à ce que les taux et les délais de plus d'unités sera expédié?

J'ai eu le même problème et pour moi, il a travaillé pour définir le TERME de variable pour rien directement avant d'exécuter cgminer. Comme cela dans la cmd shell:

DURÉE=
cgminer-nogpu.exe ........

Si vous le réglez sur "" (sens rien) dans les paramètres du système, il va utiliser la valeur par défaut "c:\windows\system32\cmd.exe". Vous pouvez consulter la variable dans la coque avec:

echo %DURÉE%

J'espère que cela va vous aider :)

Ce qui arrive à une personne bitcoins si elles se produisent à mourir prématurément? Les pièces de monnaie perdues à jamais si on ne sait pas que la personne porte-monnaie info?

La réponse courte à votre question est "oui".

Des Efforts sont en cours pour mettre au point des mécanismes qui permettent de collectifs d'exploration sans le gestionnaire de pool d'être en mesure de contrôler ce que les transactions vont dans la piscine de blocs, laissant cette décision (ainsi que de la chaîne d'étendre, tant que c'est raisonnable) à la personne de mineurs. Tous les la piscine a vraiment besoin est une preuve que le mineur est l'exploitation minière, pour la piscine.

J'ai un 2012 Macbook Pro minière Litecoins (CPU&GPU à un combiné 80kHash/s) et un iMac 2011 (71MHash/s sur son HD5670) exploration de la CTB. Ils ont tous les deux tourner toute la nuit et le week-end, je tourne le logiciel d'exploration sur le jour de la semaine. Faire ce depuis des mois maintenant.

Jusqu'à présent, il n'y avait pas de problèmes de surchauffe, mais j'ai un supplément de support de refroidissement pour le Macbook, que je recommande.

Encore, je m'attends à du matériel de mourir plus tôt. La gestion de la chaleur dans les machines Apple est très délicate en raison de la conception de cas, et j'ai entendu des gens se réveiller un mort iMac.

L'exploitation minière fournit un moyen de parvenir à un consensus sur ce que les transactions du grand livre et de savoir que personne ne triche.

C'est la non-définition technique de l'exploitation minière.

• Quel est exactement l'exploitation Minière?

L ' "autorité" pour doubler les dépenses est la blockchain. La blockchain se compose de l'histoire de tous les blocs dans la blockchain plus le prochain bloc de transactions. La récompense subvention actuellement est de 25 BTC à la partie qui soumet le prochain bloc. Mais bon ...vous voulez que 25 BTC (vaut actuellement environ 825$) que serais-je comme tout le monde. Alors, comment faire en sorte que je ne peut pas tricher et de réclamer le bloc de moi-même?

Eh bien, vous mettre dans un système que vous et moi avons à la concurrence. C'est ce que la preuve de travail fait-il qu'il fait en sorte que lorsque je demande la récompense, il est facile de prouver que j'ai vraiment fait le travail. Donc, pour moi, d'avoir 2% de chance de résoudre un bloc que je dois mettre dans 2% des de la des travaux d'exploitation. Il n'y a aucun moyen pour moi de mettre en moins de 2% de tout le travail et encore résoudre des blocs d'au moins 2% du temps (en moyenne).

Donc en conséquence, lors d'une transaction de bloc est soumis, tous les pairs de vérifier qu'il n'y avait pas de double dépense, que le bon montant de subvention a été demandée, et que le demandeur vraiment dépensé le travail nécessaire pour cette solution. Avec ces trois règles, alors il n'a pas besoin d'être une autorité centrale chargée de gérer le processus ou en mesure de contrôler le résultat.

Voici un script Python qui fait la conversion. Vous pouvez le vérifier son travail en le comparant à la saisie de votre clé privée comme le "Secret de l'Exposant" à Brainwallet. J'ai pris le script de cette Bitcointalk fil et dépouillé inutile (comme le code pour utiliser la clé publique pour signer un message et de vérifier que la signature).

La conversion de l'Python instructions pour un homme est laissé comme exercice au lecteur (bien que je dirais que, dans un tel scénario, le code Python, avec la documentation appropriée, c'est très bien que les instructions pour l'homme). Notez qu'il est tout à fait possible pour le calcul de ce avec un stylo et du papier, mais il pourrait prendre un certain temps, et vous êtes susceptible de faire une erreur, en raison d'avoir à faire face à de tels chiffres énormes.

Notez également qu'il n'y a pas d'opérations individuelles ici beaucoup plus compliqué qu'on apprend en primaire/école élémentaire. Il y a de base des comparaisons < > ==arithmétiques + - *, de la division où vous vous souciez du quotient /, reste %, ou les deux divmod, et au niveau du bit (&, ce qui est assez facile si vous travaillez dans l'hex; ou peuvent être reproduits avec l'arithmétique).

Je ne pense pas qu'une (non-génie) de 5 ans pourrait le faire (désolé, la méchante sorcière gagne ce tour), mais je pense qu'un adulte de taille moyenne avec suffisamment de patience pourrait apprendre les mathématiques nécessaires dans presque pas de temps (avec le script Python comme un..bien..script, à suivre). En fait, le calcul même une clé publique sans l'aide de l'électronique des appareils pourrait prendre un temps très long, cependant (à deviner: ans).

#! /usr/bin/env python
# python 2.x

classe CurveFp( objet ):
 def __init__( self, p, a, b ):
 self.__p = p
 self.__a = a
 self.__b = b

 def p( self ):
 retour auto.__p

 def a( auto ):
 retour auto.__un

 def b( auto ):
 retour auto.__b

 def contains_point( self, x, y ):
 de retour ( y * y - ( x * x * x + self.__a * x + self.__b ) ) % self.__p == 0

la classe Point( objet ):
 def __init__( self, courbe, x, y, commande = None ):
 self.__courbe = courbe
 self.__x = x
 self.__y = y
 self.__order = ordre
 si l'auto.__courbe: affirmer soi-même.__de la courbe.contains_point( x, y )
 si la commande: affirmer l'autonomie * commande == INFINI

 def __add__( self, autre ):
 si d'autres == l'INFINI: le retour de l'auto
 si l' == l'INFINI: au retour de l'
 affirmer soi-même.__courbe == autres.__courbe
 si l'auto.__x == autres.__x:
 if ( self.__y + autres.__y ) % self.__de la courbe.p() == 0:
 retour INFINI
autre chose:
 retour auto.double()

 p = self.__de la courbe.p()
 l = ( ( d'autres.__y - auto.__y ) * \
 inverse_mod( d'autres.__x - auto.__x, p ) ) % p
 x3 = ( l * l - auto.__x - autres.__x ) % p
 y3 = ( l * ( self.__x - x3 ) - auto.__y ) % p
 Point de retour( self.__courbe, x3, y3 )

 def __mul__( self, autre ):
 def leftmost_bit( x ):
 assert x > 0
 résultat = 1L
 tout résultat <= x: résultat = 2 * résultat
 résultat de retour / 2

 e = autres
 si l'auto.__ordre: e = e % self.__afin
 si e == 0: return INFINI
 si l' == INFINI: retour INFINI
 affirmer e > 0
 e3 = 3 * e
 negative_self = Point( self.__courbe, self.__x, -auto.__y, self.__commande )
 i = leftmost_bit( e3 ) / 2
 résultat = auto
 tout i > 1:
 résultat = résultat.double()
 si e3 (&i ) != 0 et ( e & i ) == 0: result = result + auto
 si e3 (&i ) == 0 et ( e & i ) != 0: result = result + negative_self
 i = i / 2
 résultat de retour

 def __rmul__( self, autre ):
 retour auto * autres

 def __str__( self ):
 si l' == INFINI: de retour de "l'infini"
 retour "(%d,%d)" % ( self.__x, self.__y )

 def double( self ):
 si l' == l'INFINI:
 retour INFINI

 p = self.__de la courbe.p()
 a = self.__de la courbe.un()
 l = ( ( 3 * self.__x * self.__x + a ) * \
 inverse_mod( 2 * self.__y, p ) ) % p
 x3 = ( l * l - 2 * self.__x ) % p
 y3 = ( l * ( self.__x - x3 ) - auto.__y ) % p
 Point de retour( self.__courbe, x3, y3 )

 def x( self ):
 retour auto.__x

 def y( self ):
 retour auto.__y

 def courbe( self ):
 retour auto.__courbe

 def commande( self ):
 retour auto.__afin

L'INFINI = Point( None, None, None )

def inverse_mod( a, m ):
 si a < 0 ou m <= a: a = a % m
 c, d = a, m
 uc, vc, ud, vd = 1, 0, 0, 1
 tandis que le c != 0:
 q, c, d = divmod( d, c ) + ( c, )
 uc, vc, ud, vd = ud - q*communications unifiées, vd - q*vc, uc, vc
 affirmer d == 1
 si ud > 0: retour ud
 autre chose: le retour ud + m

# secp256k1
_p = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFfffffffffffffffffffffffffefffffc2fl
_r = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFfebaaedce6af48a03bbfd25e8cd0364141l
_b = 0x0000000000000000000000000000000000000000000000000000000000000007l
_a = 0x0000000000000000000000000000000000000000000000000000000000000000l
_Gx = 0x79BE667EF9DCBBAC55A06295CE870B07029bfcdb2dce28d959f2815b16f81798l
_Gy = 0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8l

classe Public_key( objet ):
 def __init__( self, générateur, point ):
 auto.courbe = générateur.la courbe()
 auto.générateur = générateur
 auto.point = point
 n = générateur.commande()
 si pas de n:
 soulever RuntimeError, "Générateur de point doit avoir de l'ordre."
 si pas de n * point == l'INFINI:
 soulever RuntimeError, "Générateur de point de commande est mauvais."
 si le point.x() < 0 ou n <= point.x() ou d'un point.y() < 0 ou n <= point.y():
 soulever RuntimeError, "Générateur de point a de x ou y de gamme."

curve_256 = CurveFp( _p, _a, _b )
generator_256 = Point( curve_256, _Gx, _Gy, _r )
g = generator_256

si __name__ == "__principaux__":
 imprimer '======================================================================='
 ### set privkey
 # wiki
 #secret = 0xE9873D79C6D87DC0FB6A5778633389f4453213303da61f20bd67fc233aa33262l
 # question
 secret = 0x18E14A7B6A307F426A94F8114701E7c8e774e7f9a47e2c2035db29a206321725l

 ### print privkey
 print "secret", hex(secret)
 ### générer pubkey
 pubkey = Public_key( g, g * secret )
 ### print pubkey
 imprimer pubkey', hex(pubkey.point.x()), hex(pubkey.point.y())
 imprimer '======================================================================='

Voir aussi du même-plus-stripped-down version écrite en C#.

classe CalcPub
{
 public static void main()
{
 var p = BigInteger.Parse("0FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F", NumberStyles.HexNumber);
 var b = (BigInteger)7;
 var a = BigInteger.Zéro;
 var Gx = BigInteger.Parse("79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798", NumberStyles.HexNumber);
 var Gy = BigInteger.Parse("483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8", NumberStyles.HexNumber);

 CurveFp curve256 = new CurveFp(p, a, b);
 Point generator256 = new Point(curve256, Gx, Gy);

 var secret = BigInteger.Parse("18E14A7B6A307F426A94F8114701E7C8E774E7F9A47E2C2035DB29A206321725", NumberStyles.HexNumber);

 Console.WriteLine("secret {0}", secret.ToString("X"));
 var pubkeyPoint = generator256 * secret;
 Console.WriteLine("pubkey {0}{1}", pubkeyPoint.X.ToString("X"), pubkeyPoint.Y.ToString("X"));
}
}
la classe Point
{
 public static readonly Point de l'INFINI = new Point(null par défaut(BigInteger), par défaut(BigInteger));
 public CurveFp Courbe { get; private set; }
 public BigInteger X { get; private set; }
 public BigInteger Y { get; private set; }

 public Point(CurveFp courbe, BigInteger x, BigInteger y)
{
 c'.Courbe = courbe;
 c'.X = x;
 c'.Y = y;
}
 public Point Double()
{
 si (ce == INFINI)
 retour INFINI;

 BigInteger p = ce.De la courbe.p;
 BigInteger a = ce.De la courbe.une;
 BigInteger l = ((3 * ce.X * ce.X + a) * InverseMod(2 * ce.Y, p)) % p;
 BigInteger x3 = (l * l - 2 * ce.X) % p;
 BigInteger y3 = (l * (ce.X - x3) - cette.Y) % p;
 de retour de new Point(ce.Courbe, x3, y3);
}
 public override string ToString()
{
 si (ce == INFINI)
 de retour de "l'infini";
 chaîne de retour.Format("({0},{1})", c'.X, cette.Y);
}
 public static Point operator +(Point, Point à droite)
{
 si (droite == INFINI)
 retour à gauche;
 si (gauche == INFINI)
 droit de retour;
 si (de gauche.X == droite.X)
{
 si ((de gauche.Y + droite.Y) % à gauche.De la courbe.p == 0)
 retour INFINI;
d'autre
 retour à gauche.Double();
}

 var p = gauche.De la courbe.p;
 var l = ((de droite.Y - gauche.Y) * InverseMod(à droite.X - gauche.X, p)) % p;
 var x3 = (l * l - gauche.X - droit.X) % p;
 var y3 = (l * (de gauche.X - x3) - gauche.Y) % p;
 de retour de new Point(de gauche.Courbe, x3, y3);
}
 public static Point de l'opérateur *(Point à gauche, BigInteger à droite)
{
 var e = droite;
 if (e == 0 || gauche == INFINI)
 retour INFINI;
 var e3 = 3 * e;
 var negativeLeft = new Point(de gauche.Courbe, à gauche.X, gauche.Y);
 var i = LeftmostBit(e3) / 2;
 var resultat = gauche;
 while (i > 1)
{
 résultat = résultat.Double();
 si ((e3 & i) != 0 && (e & i) == 0)
 résultat += gauche;
 si ((e3 & i) == 0 && (e & i) != 0)
 résultat += negativeLeft;
 i /= 2;
}
 résultat de retour;
}

 private static BigInteger LeftmostBit(BigInteger x)
{
 BigInteger result = 1;
 while (result <= x)
 résultat = 2 * résultat;
 résultat de retour / 2;
}
 private static BigInteger InverseMod(BigInteger un, BigInteger m)
{
 while (a < 0) a += m;
 si (a < 0 || m <= a)
 a = a % m;
 BigInteger c = a;
 BigInteger d = m;

 BigInteger uc = 1;
 BigInteger vc = 0;
 BigInteger ud = 0;
 BigInteger vd = 1;

 while (c != 0)
{
 BigInteger r;
 //q, c, d = divmod( d, c ) + ( c, );
 var q = BigInteger.DivRem(d, c, r);
 d = c;
 c = r;

 //uc, vc, ud, vd = ud - q*communications unifiées, vd - q*vc, uc, vc;
 var uct = uc;
 var cdv = vc;
 var udt = ud;
 var vdt = vd;
 uc = udt - q * uct;
 vc = vdt - q * cdv;
 ud = uct;
 vd = vct;
}
 si (ud > 0) return ud;
 else return ud + m;
}
}
classe CurveFp
{
 public BigInteger p { get; private set; }
 public BigInteger un { get; private set; }
 public BigInteger b { get; private set; }
 public CurveFp(BigInteger p, BigInteger un, BigInteger b)
{
 c'.p = p;
 c'.a = a;
 c'.b = b;
}
}

Vous êtes à la recherche de moyens d'améliorer l'protections contre les défauts?

Voici une liste de ses protections:

• http://en.bitcoin.it/wiki/Weaknesses#Denial_of_Service_.28DoS.29_attacks

erreur: contrôle de l'annuaire a de mauvaises permissions 777 (doit être >=0755 et <=0775)

Pourrait-il être un problème de permissions?

Yuma père Yugo a travaillé avec des Frontières quand il a été fondé, il a donc dû Déclencher la technologie de l'époque. Alors, quand Yuma abord utilisé une Frontière Déclencher ans, lorsque son père, le Trion corps et uniforme conçu pour lui est venu de la frontière vieux jours. Pour lui, il utilise la même Trion corps maintenant avec le noir uniforme, plutôt que de faire un nouveau Trion corps avec de la Frontière actuelle de blanc.

Un exemple de ce que je veux dire, c'est Konami Yuma mentor, a dit qu'elle a été en Bordure même avant de Jin. Elle avait les cheveux courts dans ses premières années, de sorte que même si elle a les cheveux longs maintenant. Elle lui permet de Trion corps à maintenir les cheveux courts, elle a l'habitude d'avoir, parce que son corps réel les cheveux longs n'est pas adapté pour la bataille. Fondamentalement, à moins que Yuma fait une nouvelle Frontière du Déclencheur, Trion corps, il aura le noir uniforme.