สร้างบล็อคเชนของคุณเอง

ขั้นตอนที่ 1 — บล็อกและลายนิ้วมือ

บล็อกเก็บข้อมูลบางส่วน (ธุรกรรม) ลิงก์ไปยังบล็อกก่อนหน้า และ "nonce" (ตัวเลขที่เราสามารถเปลี่ยนแปลงได้) ข้อมูลประจำตัวของมันคือแฮช SHA-256 ของเนื้อหาทั้งหมด - เปลี่ยนอักขระหนึ่งตัวและแฮชจะเปลี่ยนทั้งหมด แฮชนั้นเป็นลายนิ้วมือที่เห็นได้ชัดของบล็อก

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()

ขั้นตอนที่ 2 — การขุด (หลักฐานการทำงาน)

การขุดหมายถึงการค้นหาแฮชที่ตรงตามกฎ — ในที่นี้เริ่มต้นด้วยจำนวนศูนย์ที่กำหนด ไม่มีสูตร; คุณบังคับโนนซ์อย่างดุร้ายจนกระทั่งแฮชเข้ากัน การตรวจสอบวิธีแก้ปัญหาทำได้ทันที แต่การค้นหาวิธีแก้ไขนั้นต้องใช้ความพยายาม ความไม่สมดุลนั้นเป็นหัวใจสำคัญของ 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()

ขั้นตอนที่ 3 – การผูกมัดบล็อก

แต่ละบล็อกใหม่จะเก็บแฮชของบล็อกก่อนหน้า โดยเชื่อมเข้าด้วยกันเป็นลูกโซ่ที่ขึ้นต้นด้วยบล็อก "genesis" แบบฮาร์ดโค้ด เนื่องจากทุกบล็อกกระทำต่อบล็อกที่อยู่ก่อนหน้า ลำดับจึงได้รับการแก้ไขและประวัติถูกเชื่อมโยงเข้าด้วยกัน

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

ขั้นตอนที่ 4 — ตรวจสอบความถูกต้องของห่วงโซ่

หากต้องการเชื่อถือ 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

ขั้นตอนที่ 5 — เรียกใช้และลองโกง

ตอนนี้เพิ่มสองสามช่วงตึกแล้วแก้ไขธุรกรรมเก่า ทันทีที่คุณเปลี่ยนข้อมูลที่ผ่านมา แฮชของบล็อกนั้นจะไม่ตรงกับสิ่งที่บล็อกถัดไปคาดหวังอีกต่อไป และการตรวจสอบความถูกต้องจะส่งคืนค่าเท็จทันที นี่คือสาเหตุโดยย่อว่าทำไมคุณไม่สามารถเขียนประวัติศาสตร์ของ 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!

สิ่งที่ Bitcoin จริงเพิ่มเข้ามา

ห่วงโซ่ของเล่นของเราสอนเรื่องโครงกระดูก Real Bitcoin เพิ่มเครือข่ายโหนดแบบ peer-to-peer ทั่วโลก ลายเซ็นดิจิทัลที่พิสูจน์ว่าใครสามารถใช้เหรียญได้ การปรับความยากอัตโนมัติ โมเดล UTXO รางวัลบล็อกและการลดครึ่งหนึ่ง และกฎฉันทามติที่ให้คนแปลกหน้าตกลงโดยไม่ไว้วางใจ สำรวจแต่ละรายการในตัวอธิบายของเราด้านล่าง

คำถามที่พบบ่อย

เรียนรู้ต่อไป