Zorluk

Zorluk

Zorluk nedir?

Bitcoin dünyasında zorluk (difficulty) belirli bir hedefin altında bir hash bulmanın ne kadar zor olabildiğinin bir ölçüsüdür.

Bitcoin ağı genel bir blok zorluğuna sahiptir. Geçerli blokların bu hedefin altında bir hash’i olmalı. Madencilik havuzlarında ayrıca, paylaşım için daha düşük bir limit belirleyerek havuza özgü bir paylaşım zorluğu vardır.

Ağın zorluğu ne sıklıkla değişir?

Her 2016 blokta.

Zorluk için formül nedir?

zorluk = zorluk_1_hedef / geçerli_target

(Hedef 256 bitlik bir sayıdır)

zorluk_1_hedef, zorluğu ölçmenin çeşitli yolları için farklı olabilir. Geleneksel olarak, önde gelen 32 bitin sıfır olduğu ve geri kalanın bir olduğu hash’i temsil eder (bu “havuz zorluğu” veya “pdiff” olarak bilinir). Bitcoin protokolü, hedefleri sınırlı hassasiyetle özel kayan nokta türü olarak temsil eder; sonuç olarak, Bitcoin istemcileri genellikle buna dayalı zorluklara yaklaşmaktadır (bu “bdiff” olarak bilinir).

Zorluk bloklarda nasıl saklanır?

Her blok, gerçek onaltılık hedefi için paketlenmiş bir gösterimi (“Bit” olarak adlandırılır) depolar. Hedef, önceden tanımlanmış bir formül vasıtasıyla türetilebilir. Örneğin, bloğun paketlenmiş hedefi 0x1b0404cb ise, onaltılık hedef

0x0404cb * 2**(8*(0x1b - 3)) = 0x00000000000404CB000000000000000000000000000000000000000000000000

0x0404cb değerinin bu formatta imzalanmış bir değer (signed value) olduğunu unutmayın. Bu alanın en büyük yasal değeri 0x7fffff’dir. Daha büyük bir değer elde etmek için tam bir bayt kaydırmanız gerekir. Ayrıca 0x008000, geçerli en küçük pozitif değerdir.

Zorluk nasıl hesaplanır? Bdiff ve pdiff arasındaki fark nedir?

Olası en yüksek hedef (zorluk 1), 0x1d00ffff olarak tanımlanır; bu da;

0x00ffff * 2**(8*(0x1d - 3)) = 0x00000000FFFF0000000000000000000000000000000000000000000000000000

Toplanan madencilik genellikle kesilmemiş hedefler kullanmaktadır ve bu da “havuz zorluğu 1” demektir;

0x00000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF

Dolayısıyla, 0x1b0404cb’deki zorluk şu şekildedir:

0x00000000FFFF0000000000000000000000000000000000000000000000000000 /
0x00000000000404CB000000000000000000000000000000000000000000000000
= 16307.420938523983 (bdiff)

ve;

0x00000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF /
0x00000000000404CB000000000000000000000000000000000000000000000000
= 16307.669773817162 (pdiff)

İşte bitcoin güç zorluğunu hesaplamak için hızlı bir yol. Logaritma için değiştirilmiş bir Taylor serisi kullanır ve zorluk hesaplamasını dönüştürmek için loglara güvenir:

#include <iostream>
#include <cmath>

inline float fast_log(float val)
{
int * const exp_ptr = reinterpret_cast <int *>(&val);
int x = *exp_ptr;
const int log_2 = ((x >> 23) & 255) - 128;
x &= ~(255 << 23);
x += 127 << 23;
*exp_ptr = x;

val = ((-1.0f/3) * val + 2) * val - 2.0f/3;
return ((val + log_2) * 0.69314718f);
}

float difficulty(unsigned int bits)
{
static double max_body = fast_log(0x00ffff), scaland = fast_log(256);
return exp(max_body - fast_log(bits & 0x00ffffff) + scaland * (0x1d - ((bits & 0xff000000) >> 24)));
}

int main()
{
std::cout << difficulty(0x1b0404cb) << std::endl;
return 0;
}

Yukarıdaki hesaplamaya normal zorluk hesaplamalardan (normal büyük sayıların büyük boşluklarından büyük herhangi bir normal tamsayı gerektiren hesaplamalara) bakmak için aşağıda bazı python kodları bulabilirsiniz:

import decimal, math
l = math.log
e = math.e

print 0x00ffff * 2**(8*(0x1d - 3)) / float(0x0404cb * 2**(8*(0x1b - 3)))
print l(0x00ffff * 2**(8*(0x1d - 3)) / float(0x0404cb * 2**(8*(0x1b - 3))))
print l(0x00ffff * 2**(8*(0x1d - 3))) - l(0x0404cb * 2**(8*(0x1b - 3)))
print l(0x00ffff) + l(2**(8*(0x1d - 3))) - l(0x0404cb) - l(2**(8*(0x1b - 3)))
print l(0x00ffff) + (8*(0x1d - 3))*l(2) - l(0x0404cb) - (8*(0x1b - 3))*l(2)
print l(0x00ffff / float(0x0404cb)) + (8*(0x1d - 3))*l(2) - (8*(0x1b - 3))*l(2)
print l(0x00ffff / float(0x0404cb)) + (0x1d - 0x1b)*l(2**8)

Mevcut zorluk seviyesi nedir?

Şu anki zorluk seviyesini buradan görebilirsiniz.

Grafikler için buraya tıklayın.

Maksimum zorluk nedir?

Minimum hedef yok. Maksimum zorluk kabaca: maksimum_hedef/1 (0 sonsuzluğa neden olacağı için), bu gülünç derecede büyük bir sayıdır (yaklaşık 2 ^ 224).

Gerçek maksimum zorluk, current_target = 0 olduğunda olur, ancak bunun olması halinde zorluğu hesaplayamayız.

Ağ zorluğu düşebilir mi?

Evet olabilir.

Minimum zorluk nedir?

Minimum zorluk, hedefin izin verilen maksimum seviyede yani 1’de olmasıdır.

Herhangi bir zorlukta hangi ağ hash oranı ortaya çıkar?

Zorluk her 2016 blokta bir önceki 2016 bloklarını bulma süresine göre ayarlanır. Her 10 dakikada bir blok hızıyla, 2016 bloğun bulunması iki haftayı bulacaktır. Önceki 2016 bloğu bulmak iki haftadan fazla sürdüyse zorluk azalır. Eğer iki haftadan az sürerse, zorluk artar. Zorluktaki değişim, önceki 2016 bloğun bulması gereken iki hafta içinde veya iki haftanın altında kalan süre ile orantılıdır.

Bir blok bulmak için, hash hedefin altında olmalıdır. Hash, 0 ile 2**256-1 arasındaki rastgele bir sayıdır. Zorluk 1 için ofset;

0xffff * 2**208

ve zorluk D için;

(0xffff * 2**208)/D

Bu nedenle D zorluğu olan bir blok bulmak için hesaplamamız gereken beklenen hash sayısı;

D * 2**256 / (0xffff * 2**208)

veya sadece;

D * 2**48 / 0xffff

Zorluk, önceki 2016 bloğun her 10 dakikada bir bulunması şeklinde ayarlandı, bu nedenle 600 saniyede (D*2**48/0xffff) hash hesaplıyorduk. Ağın hash oranı şu an;

D * 2**48 / 0xffff / 600

Çok fazla doğruluk kaybı olmadan, daha da basitleştirilebilir;

D * 2**32 / 600

Zorluk 1’de saniyede yaklaşık 7 Mhash var.

Yazma sırasındaki zorluk 22012.4941572’dir, yani önceki 2016 blok setinde ortalama ağ hash oranı şu şekilde olmuştur:

22012.4941572 * 2 ** 32/600 = saniyede 157 Ghash civarında.

Ne kadar kısa sürede bir blok üretebilirim?

Bakınız: Sonsuzluk sorusu.

Bir blok bulma ortalama süresi şöyle hesaplanabilir:

Zaman = zorluk * 2 ** 32 / hashrate

Zorluk: şu anki zorluk seviyesi,

Hashrate: madencinin saniyede hesapladığı hash’lerin sayısı,

Zaman: bulunan bloklar arasındaki saniye cinsinden ortalama süredir.

Örneğin, Python kullanarak zorluk 20000 olduğunda bir 1Ghash/s madencilik teçhizatı kullanarak bir blok oluşturmanın ortalama süresini hesaplıyoruz:

$ python -c "print 20000 * 2**32 / 10**9 / 60 / 60.0"
23.85

Yukarıdaki örnekte sonuç ortalama olarak 24 saatin biraz altındadır.

Hesaplama yapmak için aşağıdaki hesap makinelerini kullanabilirsiniz:

Leave a comment

E-posta hesabınız yayımlanmayacak. Gerekli alanlar * ile işaretlenmişlerdir