Blockchain Basics

Blockchain Basics Skill

Master blockchain fundamentals including consensus mechanisms, cryptographic primitives, and distributed systems architecture.

Quick Start

# Invoke this skill for blockchain fundamentals
Skill("blockchain-basics", topic="consensus", depth="intermediate")

Topics Covered

1. Consensus Mechanisms

Learn how distributed networks achieve agreement:

• Proof of Work: Mining, hashrate, difficulty adjustment
• Proof of Stake: Validators, slashing, finality
• Byzantine Fault Tolerance: Leader election, view changes

2. Cryptographic Foundations

Understand the security primitives:

• Hash Functions: SHA-256, Keccak-256, properties
• Digital Signatures: ECDSA, Ed25519, verification
• Merkle Trees: Proof construction, verification

3. Network Architecture

Explore distributed systems:

• P2P Networks: Gossip protocols, peer discovery
• Node Types: Full nodes, light clients, archives
• Block Propagation: Compact blocks, relay networks

4. Transaction Lifecycle

Follow data through the chain:

• Transaction Structure: Inputs, outputs, signatures
• Mempool: Fee markets, ordering, priority
• Confirmation: Finality, reorganization

Code Examples

Verify Merkle Proof

import hashlib

def verify_merkle_proof(leaf: bytes, proof: list, root: bytes) -> bool:
    """Verify a Merkle proof for inclusion"""
    current = leaf
    for sibling, is_left in proof:
        if is_left:
            current = hashlib.sha256(sibling + current).digest()
        else:
            current = hashlib.sha256(current + sibling).digest()
    return current == root

Calculate Block Hash

import hashlib
import struct

def calculate_block_hash(header: dict) -> bytes:
    """Calculate Bitcoin-style block hash"""
    data = struct.pack(
        '<I32s32sIII',
        header['version'],
        bytes.fromhex(header['prev_block']),
        bytes.fromhex(header['merkle_root']),
        header['timestamp'],
        header['bits'],
        header['nonce']
    )
    return hashlib.sha256(hashlib.sha256(data).digest()).digest()[::-1]

Common Pitfalls

Troubleshooting

"Why is my transaction not confirming?"

1. Check transaction fee vs current mempool 2. Verify nonce is sequential (no gaps) 3. Ensure sufficient balance for amount + gas

"How do I verify a signature?"

from eth_account import Account
from eth_account.messages import encode_defunct

message = encode_defunct(text="Hello")
address = Account.recover_message(message, signature=sig)

Learning Path

[Beginner] → Hash Functions → Digital Signatures → Transactions
    ↓
[Intermediate] → Merkle Trees → Consensus → Network Layer
    ↓
[Advanced] → BFT Protocols → Sharding → Cross-chain

Test Yourself

# Unit test template
def test_merkle_root():
    txs = [b"tx1", b"tx2", b"tx3", b"tx4"]
    root = build_merkle_root(txs)
    assert len(root) == 32
    assert verify_merkle_proof(txs[0], get_proof(0), root)

Cross-References

• Bonded Agent: 01-blockchain-fundamentals
• Related Skills: ethereum-development, smart-contract-security

Version History

Blockchain Basics Guide

Overview

This guide provides comprehensive documentation for the blockchain-basics skill in the custom-plugin-blockchain plugin.

Category: Machine-Learning

Quick Start

Prerequisites

• Familiarity with machine-learning concepts
• Development environment set up
• Plugin installed and configured

Basic Usage

# Invoke the skill
claude "blockchain-basics - [your task description]"

# Example
claude "blockchain-basics - analyze the current implementation"

Core Concepts

Key Principles

1. Consistency - Follow established patterns 2. Clarity - Write readable, maintainable code 3. Quality - Validate before deployment

Best Practices

• Always validate input data
• Handle edge cases explicitly
• Document your decisions
• Write tests for critical paths

Common Tasks

Task 1: Basic Implementation

# Example implementation pattern
def implement_blockchain_basics(input_data):
    """
    Implement blockchain-basics functionality.

    Args:
        input_data: Input to process

    Returns:
        Processed result
    """
    # Validate input
    if not input_data:
        raise ValueError("Input required")

    # Process
    result = process(input_data)

    # Return
    return result

Task 2: Advanced Usage

For advanced scenarios, consider:

• Configuration customization via assets/config.yaml
• Validation using scripts/validate.py
• Integration with other skills

Troubleshooting

Common Issues

Related Resources

• SKILL.md - Skill specification
• config.yaml - Configuration options
• validate.py - Validation script

---

Last updated: 2025-12-30

Blockchain Basics Patterns

Design Patterns

Pattern 1: Input Validation

Always validate input before processing:

def validate_input(data):
    if data is None:
        raise ValueError("Data cannot be None")
    if not isinstance(data, dict):
        raise TypeError("Data must be a dictionary")
    return True

Pattern 2: Error Handling

Use consistent error handling:

try:
    result = risky_operation()
except SpecificError as e:
    logger.error(f"Operation failed: {e}")
    handle_error(e)
except Exception as e:
    logger.exception("Unexpected error")
    raise

Pattern 3: Configuration Loading

Load and validate configuration:

import yaml

def load_config(config_path):
    with open(config_path) as f:
        config = yaml.safe_load(f)
    validate_config(config)
    return config

Anti-Patterns to Avoid

❌ Don't: Swallow Exceptions

# BAD
try:
    do_something()
except:
    pass

✅ Do: Handle Explicitly

# GOOD
try:
    do_something()
except SpecificError as e:
    logger.warning(f"Expected error: {e}")
    return default_value

Category-Specific Patterns: Machine-Learning

Recommended Approach

1. Start with the simplest implementation 2. Add complexity only when needed 3. Test each addition 4. Document decisions

Common Integration Points

• Configuration: assets/config.yaml
• Validation: scripts/validate.py
• Documentation: references/GUIDE.md

---

Pattern library for blockchain-basics skill