Das deutsche Python-Forum

Code: Alles auswählen

"""
https://andersbrownworth.com/blockchain/blockchain
"""

"""
var difficulty = 4;        // number of zeros required at front of hash
var maximumNonce = 500000; // limit the nonce to this so we don't mine too long

// NOTE: Because there are 16 possible characters in a hex value, each time you increment
// the difficulty by one you make the puzzle 16 times harder. In my testing, a difficulty
// of 6 requires a maximumNonce well over 500,000,000.

/////////////////////////
// global variable setup
/////////////////////////
var pattern = '';
for (var x=0; x<difficulty; x++) {
  pattern += '0';
}

/////////////////////////
// functions
/////////////////////////
function sha256(block, chain) {
  // calculate a SHA256 hash of the contents of the block
  return CryptoJS.SHA256(getText(block, chain));
}

function updateState(block, chain) {
  // set the well background red or green for this block
  if ($('#block'+block+'chain'+chain+'hash').val().substr(0, difficulty) === pattern) {
    $('#block'+block+'chain'+chain+'well').removeClass('well-error').addClass('well-success');
  }
  else {
    $('#block'+block+'chain'+chain+'well').removeClass('well-success').addClass('well-error');
  }
}

function updateHash(block, chain) {
  // update the SHA256 hash value for this block
  $('#block'+block+'chain'+chain+'hash').val(sha256(block, chain));
  updateState(block, chain);
}

function updateChain(block, chain) {
  // update all blocks walking the chain from this block to the end
  for (var x = block; x <= 5; x++) {
    if (x > 1) {
      $('#block'+x+'chain'+chain+'previous').val($('#block'+(x-1).toString()+'chain'+chain+'hash').val());
    }
    updateHash(x, chain);
  }
}

function mine(block, chain, isChain) {
  for (var x = 0; x <= maximumNonce; x++) {
    $('#block'+block+'chain'+chain+'nonce').val(x);
    $('#block'+block+'chain'+chain+'hash').val(sha256(block, chain));
    if ($('#block'+block+'chain'+chain+'hash').val().substr(0, difficulty) === pattern) {
      if (isChain) {
        updateChain(block, chain);
      }
      else {
        updateState(block, chain);
      }
      break;
    }
  }
}
"""

# setup chain
"""
$(function() {
  setup(1, 1);
  setup(2, 1);
  setup(3, 1);
  setup(4, 1);
  setup(5, 1);
});

function getText(block, chain) {
  return $('#block'+block+'chain'+chain+'number').val() +
         $('#block'+block+'chain'+chain+'nonce').val() +
         $('#block'+block+'chain'+chain+'data').val() +
         $('#block'+block+'chain'+chain+'previous').val();
}

function setup(block, chain) {
  updateHash(block, chain);
  $('#block'+block+'chain'+chain+'number').bind('input propertychange', function() { updateChain(block, chain); });
  $('#block'+block+'chain'+chain+'nonce').bind('input propertychange', function() { updateChain(block, chain); });
  $('#block'+block+'chain'+chain+'data').bind('input propertychange', function() { updateChain(block, chain); });
  $('#block'+block+'chain'+chain+'mineButton').click(function(e) {
      e.preventDefault();
      var l = Ladda.create(this);
      l.start();
      setTimeout(function() {
          mine(block, chain, true);
          l.stop();
        }, 250); // give UI time to update
    });
}
"""
from dataclasses import dataclass, field
from hashlib import sha256


DIFFICULTY = 4
MAXIMUM_NONCE = 500000
PATTERN = "0" * DIFFICULTY


@dataclass
class Block:
    number: int
    nonce: int | None = field(default=-1)
    data: str = field(default="")
    chain: int = field(default=1)
    previous: str = field(default="0" * 64)

    @property
    def hash(self):
        return sha256(
            f"{self.number}{self.nonce}{self.data}{self.previous}".encode(),
        ).hexdigest()

    @property
    def is_valid(self):
        return self.hash[:DIFFICULTY] == PATTERN

    def find_nonce(self):
        for nonce in range(MAXIMUM_NONCE):
            self.nonce = nonce
            if self.is_valid:
                return True

        self.nonce = -1
        return False


@dataclass
class Chain:
    blocks: list[Block] = field(default_factory=list)

    def add_block(self, data: str):
        if size := len(self):
            block_number = size + 1
            hash_prev = self[block_number - 2].hash
        else:
            block_number = 1
            hash_prev = "0" * 64

        self.blocks.append(Block(number=block_number, data=data, previous=hash_prev))

    def __getitem__(self, block_number: int) -> Block:
        return self.blocks[block_number]

    def __len__(self):
        return len(self.blocks)

    def find_nonces(self):
        for index, block in enumerate(self):
            if index > 0:
                block.previous = self[index - 1].hash

            if not block.find_nonce():
                raise RuntimeError(
                    "Konnte nonce nicht berechnen, da das Limit erreicht worden ist."
                )


chain1 = Chain()
chain1.add_block("a")
chain1.add_block("b")
chain1.add_block("c")
chain1.find_nonces()

for block in chain1:
    print(f"#{block.number} | Nonce: {block.nonce} | Hash: {block.hash}")

print()

Code: Alles auswählen

In [8]:   b'0' * 64
Out[8]: b'0000000000000000000000000000000000000000000000000000000000000000'

In [9]:   '0' * 64
Out[9]: '0000000000000000000000000000000000000000000000000000000000000000'

In [10]: b'0' * 64 == '0' * 64
Out[10]: False

Code: Alles auswählen

from hashlib import sha256

DIFFICULTY = 4
MAXIMUM_NONCE = 500000
PATTERN = "0" * DIFFICULTY


def calculate_hash(number, nonce, data, previous):
    return sha256(
        f"{number}{nonce}{data}{previous}".encode(),
    ).hexdigest()


def find_nonce(number, data, previous):
    nonce = 0
    for nonce in range(MAXIMUM_NONCE):
        hash = calculate_hash(number, nonce, data, previous)
        if hash[:DIFFICULTY] == PATTERN:
            return nonce, hash
    raise RuntimeError(
        "Konnte nonce nicht berechnen, da das Limit erreicht worden ist."
    )


def calculate_chain(blocks):
    previous = "0" * 64
    for number, block in enumerate(blocks, 1):
        nonce, hash = find_nonce(number, block, previous)
        print(f"#{number} | Nonce: {nonce} | Hash: {hash}")
        previous = hash


def main():
    calculate_chain(["a", "b", "c"])


if __name__ == "__main__":
    main()