Bumuo ng Iyong Sariling Blockchain

Hakbang 1 — Isang bloke at fingerprint nito

Ang isang bloke ay nagtataglay ng ilang data (mga transaksyon), isang link sa nakaraang bloke, at isang "nonce" (isang numero na maaari nating baguhin). Ang pagkakakilanlan nito ay isang SHA-256 hash ng lahat ng nilalaman nito — baguhin ang isang character at ganap na magbabago ang hash. Ang hash na iyon ay ang tamper-event na fingerprint ng block.

import hashlib, json, time

class Block:
    def __init__(self, index, transactions, previous_hash, nonce=0):
        self.index = index
        self.timestamp = time.time()
        self.transactions = transactions
        self.previous_hash = previous_hash
        self.nonce = nonce

    def hash(self):
        # A block's fingerprint = SHA-256 of all its contents.
        payload = json.dumps({
            "index": self.index,
            "timestamp": self.timestamp,
            "transactions": self.transactions,
            "previous_hash": self.previous_hash,
            "nonce": self.nonce,
        }, sort_keys=True).encode()
        return hashlib.sha256(payload).hexdigest()

Hakbang 2 — Pagmimina (Katunayan ng Trabaho)

Ang ibig sabihin ng pagmimina ay paghahanap ng hash na nakakatugon sa isang panuntunan — dito, simula sa isang set na bilang ng mga zero. Walang formula; pilitin mo ang nonce hanggang magkasya ang hash. Ang pagsuri ng solusyon ay madalian, ngunit ang paghahanap ng isa ay nangangailangan ng trabaho. Ang kawalaan ng simetrya ay ang puso ng Proof of Work.

DIFFICULTY = 4  # require this many leading zeros

def mine(block):
    # Proof of Work: keep changing the nonce until the hash
    # starts with DIFFICULTY zeros. There is no shortcut —
    # you just have to guess, which is what costs energy.
    target = "0" * DIFFICULTY
    while not block.hash().startswith(target):
        block.nonce += 1
    return block.hash()

Hakbang 3 - Pagkakadena ng mga bloke

Ang bawat bagong block ay nag-iimbak ng hash ng nauna, hinang ang mga ito sa isang chain na nagsisimula sa isang hard-coded na "genesis" block. Dahil ang bawat bloke ay commit sa isa bago nito, ang pagkakasunud-sunod ay naayos at ang kasaysayan ay magkakaugnay.

class Blockchain:
    def __init__(self):
        # The genesis block — the very first, hard-coded block.
        genesis = Block(0, [{"note": "genesis"}], "0")
        mine(genesis)
        self.chain = [genesis]

    def add_block(self, transactions):
        prev = self.chain[-1]
        block = Block(len(self.chain), transactions, prev.hash())
        mine(block)            # do the work
        self.chain.append(block)
        return block

Hakbang 4 — Pagpapatunay sa chain

Upang magtiwala sa isang chain, muli mong suriin ito: ang bawat bloke ay dapat tumuro sa tunay na hash ng nakaraang bloke, at ang bawat bloke ay dapat matugunan ang proof-of-work na panuntunan. Kung mabigo ang alinmang tseke kahit saan, hindi wasto ang chain.

def is_valid(chain):
    for i in range(1, len(chain)):
        current, previous = chain[i], chain[i - 1]
        # 1) Each block must point to the real hash of the one before it.
        if current.previous_hash != previous.hash():
            return False
        # 2) Each block must satisfy the proof-of-work rule.
        if not current.hash().startswith("0" * DIFFICULTY):
            return False
    return True

Hakbang 5 — Patakbuhin ito at subukang mandaya

Ngayon magdagdag ng ilang mga bloke at pagkatapos ay pakialaman ang isang lumang transaksyon. Sa sandaling binago mo ang nakaraang data, hindi na tumutugma ang hash ng block na iyon sa inaasahan ng susunod na block — at ang validation ay agad na nagbabalik ng False. Ito ay, sa maliit na larawan, kung bakit hindi mo maaaring tahimik na muling isulat ang kasaysayan ng Bitcoin.

bc = Blockchain()
bc.add_block([{"from": "Alice", "to": "Bob", "amount": 5}])
bc.add_block([{"from": "Bob", "to": "Carol", "amount": 2}])

print("Chain valid?", is_valid(bc.chain))   # True

# Now try to cheat: tamper with an old transaction.
bc.chain[1].transactions[0]["amount"] = 5000
print("Chain valid?", is_valid(bc.chain))   # False — tampering is caught!

Ano ang idinagdag ng totoong Bitcoin

Ang aming kadena ng laruan ay nagtuturo sa kalansay. Ang Real Bitcoin ay nagdaragdag ng isang pandaigdigang peer-to-peer network ng mga node, mga digital na lagda na nagpapatunay kung sino ang maaaring gumastos ng mga barya, awtomatikong pagsasaayos ng kahirapan, ang modelo ng UTXO, hinaharangan ang mga reward at halvings, at ang mga panuntunan ng pinagkasunduan na nagpapahintulot sa mga estranghero na sumang-ayon nang walang tiwala. Galugarin ang bawat isa sa aming mga nagpapaliwanag sa ibaba.

Mga madalas itanong

Patuloy na matuto