Permissionless Validation (Hypothetical System)

Thought Experiment

This document describes a hypothetical permissionless validation system that serves as a thought experiment for potential future architectures. This is NOT the current implementation of the DIG Network. The current system uses a validator multisig as described in the main documentation.

💜 Support the DIG Network

Help build the future of decentralized storage! The DIG Network is an open-source project that needs community support to continue development.

💜 Support the Project → - Donate crypto, buy NFTs, or sponsor development

Overview

This document explores a hypothetical future where the DIG Network could transition to a fully permissionless validation system where Chia farmers compete to spend the Rewards Distributor coin by being the first to provide a valid Proof of Space and Time along with their PlotCoin validation package. This dual-farming approach allows farmers to simultaneously farm on both the Chia Network and DIG Network using the same plot files, with no additional hardware or energy requirements.

When integrated into Chia's farming client, this system instantly bootstraps a massive validator network by leveraging Chia's existing infrastructure. Farmers check their plots for both Chia proofs and DIG validation opportunities in parallel. The first farmer to find a qualifying proof that meets the current difficulty can spend the Rewards Distributor coin, claim validator rewards, and distribute payments to validated storage providers. Each successful spend creates the seed for the next validation round, forming a chain of validation epochs while the difficulty automatically adjusts to maintain consistent ~16 minute intervals between spends.

Architecture

Dual Farming Flow

Chia Farming Client (Enhanced)
├── Check plots for Chia challenges
│   └── Submit proofs to Chia network
└── Check plots for DIG challenges (parallel)
    ├── Calculate current DIG challenge
    ├── Find qualifying proofs
    └── Race to spend Rewards Distributor

DIG Challenge Components:
1. Last distributor spend hash (challenge seed)
2. Current difficulty target
3. PlotCoin validation requirements
4. Timing window (blocks since last spend)

Competitive Mechanism

def dig_farming_loop():
    while True:
        # Get current DIG challenge
        challenge = get_current_dig_challenge()
        last_spend_hash = challenge.last_distributor_spend_hash
        difficulty = challenge.current_difficulty
        
        # Check all plots for qualifying proofs
        for plot in farmer_plots:
            # Generate proof of space
            proof = plot.get_proof_of_space(last_spend_hash)
            
            # Check if proof meets difficulty
            if proof.quality >= difficulty:
                # Race to spend! Prepare validation package
                validation_package = create_validation_package(proof)
                
                # Attempt to spend Rewards Distributor coin
                if attempt_spend(validation_package, proof):
                    claim_rewards()
                    break

Core Mechanism

class DualFarmingValidator:
    def __init__(self, chia_farmer):
        self.farmer = chia_farmer
        self.plots = chia_farmer.get_plots()
        
    def farm_for_dig_validation(self):
        """
        Continuously check plots for DIG validation opportunities
        """
        while True:
            # 1. Get current DIG challenge
            challenge = get_current_dig_challenge()
            last_spend_hash = challenge.last_distributor_spend_hash
            current_difficulty = challenge.difficulty_target
            
            # 2. Check each plot for qualifying proofs
            for plot in self.plots:
                # Generate proof of space for DIG challenge
                proof_of_space = plot.get_proof_of_space(last_spend_hash)
                
                # Check if we found a winning proof
                if proof_of_space.passes_filter(current_difficulty):
                    # 3. We found a potential winner! Quickly validate PlotCoins
                    validation_package = self.create_validation_package(
                        last_spend_hash,
                        plot.plot_id
                    )
                    
                    # 4. Create spend bundle with proof
                    spend_bundle = create_spend_bundle(
                        proof_of_space,
                        validation_package,
                        self.farmer.keys
                    )
                    
                    # 5. Race to submit!
                    if submit_to_mempool(spend_bundle):
                        print(f"Won validation round! Rewards claimed.")
                        return True
                        
            # Check if someone else won this round
            if new_distributor_spend_detected():
                continue  # Start checking for next round

Deterministic Assignment

def select_plotcoins_for_validator(last_distributor_hash, validator_pubkey):
    """
    Two-step deterministic assignment:
    1. Select up to 10 capsules based on validator's unique seed
2. From all PlotCoins of those capsules, select up to 10 to validate
    
    Inputs:
    - Last Rewards Distributor spend block hash (ensures freshness)
    - Validator's public key (ensures unique assignment)
    """
    # Create unique seed for this validator
    validator_seed = sha256(last_distributor_hash + validator_pubkey)
    
    # Step 1: Select up to 10 capsules deterministically
all_capsules = get_all_network_capsules()
selected_capsules = []
max_capsules = 10

for i in range(max_capsules):
    if i >= len(all_capsules):
        break
    capsule_index = sha256(validator_seed + i) % len(all_capsules)
    capsule_id = all_capsules[capsule_index]
    if capsule_id not in selected_capsules:  # Avoid duplicates
        selected_capsules.append(capsule_id)

# Step 2: Get all PlotCoins for selected capsules
all_plotcoins = []
for capsule_id in selected_capsules:
    plotcoins_for_capsule = get_plotcoins_for_capsule(capsule_id)
    all_plotcoins.extend(plotcoins_for_capsule)
    
    # Step 3: Deterministically select up to 10 PlotCoins from combined set
    if len(all_plotcoins) == 0:
        return []
    
    assigned_plotcoins = []
    max_plotcoins = 10
    plotcoin_seed = sha256(validator_seed + "plotcoin_selection")
    
    for i in range(min(max_plotcoins, len(all_plotcoins))):
        plotcoin_index = sha256(plotcoin_seed + i) % len(all_plotcoins)
        plotcoin = all_plotcoins[plotcoin_index]
        
        if plotcoin not in assigned_plotcoins:  # Avoid duplicates
            assigned_plotcoins.append(plotcoin)
    
    return assigned_plotcoins

Validation Flow

1. Dual Farming Setup

Farmers participate by:

• Running enhanced Chia farming client with DIG support
• Using existing Chia plots (no new plots needed)
• Checking for both Chia and DIG proofs simultaneously
• No additional hardware or energy consumption

2. Challenge and Response

def get_current_dig_challenge():
    """
    Get the current DIG validation challenge
    """
    last_spend = get_last_rewards_distributor_spend()
    
    return {
        'challenge_hash': last_spend.block_hash,
        'difficulty_target': calculate_current_difficulty(last_spend),
        'blocks_elapsed': current_block_height() - last_spend.height,
        'reward_amount': get_epoch_rewards(),
        'validation_requirements': {
            'min_plotcoins': 1,
            'max_plotcoins': 10
        }
    }

def check_plot_for_dig_proof(plot, challenge_hash, difficulty):
    """
    Check if a plot contains a winning proof
    """
    # Generate proof of space using challenge
    proof_of_space = plot.calculate_proof(challenge_hash)
    
    # Calculate quality score
    quality = calculate_quality(proof_of_space, plot.plot_id)
    
    # Check if quality meets difficulty requirement
    required_iterations = calculate_iterations_required(quality, difficulty)
    
    return {
        'qualifies': required_iterations < MAX_ITERATIONS,
        'proof': proof_of_space,
        'quality': quality,
        'iterations': required_iterations
    }

3. Winning and Validation

def create_validation_package(challenge_hash, plot_id):
    """
    When a farmer finds a winning proof, quickly create validation package
    """
    # Deterministically select PlotCoins based on winner's plot_id
    farmer_pubkey = get_farmer_pubkey_from_plot(plot_id)
    assigned_plotcoins = select_plotcoins_for_validator(
        challenge_hash,
        farmer_pubkey
    )
    
    # Quickly validate assigned PlotCoins
    validations = []
    for plotcoin in assigned_plotcoins[:10]:  # Max 10
        result = fast_validate_plotcoin(plotcoin)
        if result.is_valid:
            validations.append({
                'plotcoin_id': plotcoin.id,
                'owner': plotcoin.owner,
                'capsule_id': plotcoin.capsule_id,
                'verification': result
            })
    
    return {
        'validator': farmer_pubkey,
        'plot_id': plot_id,
        'validations': validations,
        'challenge_hash': challenge_hash,
        'timestamp': current_time()
    }

def create_spend_bundle(proof_of_space, validation_package, farmer_keys):
    """
    Create the spend bundle to claim rewards
    """
    # Create coin spend for Rewards Distributor
    coin_spend = create_coin_spend(
        coin=get_rewards_distributor_coin(),
        solution={
            'proof_of_space': proof_of_space,
            'validation_package': validation_package,
            'next_distributor_puzzle_hash': calculate_next_puzzle_hash(),
            'reward_distributions': calculate_reward_distributions(validation_package)
        }
    )
    
    # Sign with farmer's keys
    signature = sign_spend_bundle(coin_spend, farmer_keys)
    
    return SpendBundle(coin_spend, signature)

4. Spend Competition

def race_to_spend_distributor(proof_of_space, validation_package):
    """
    Multiple farmers may find valid proofs - first to spend wins
    """
    spend_bundle = create_spend_bundle(
        proof_of_space,
        validation_package,
        farmer_keys
    )
    
    try:
        # Submit to Chia mempool
        response = submit_spend_bundle(spend_bundle)
        
        if response.success:
            print(f"Successfully won validation round!")
            print(f"Rewards distributed to {len(validation_package['validations'])} providers")
            return True
        else:
            # Someone else won the race
            print(f"Lost the race: {response.error}")
            return False
            
    except Exception as e:
        print(f"Failed to submit: {e}")
        return False

def monitor_for_next_round():
    """
    Watch for new distributor spends to start next round
    """
    def on_new_distributor_spend(new_spend):
        # New round started!
        new_challenge = {
            'hash': new_spend.block_hash,
            'height': new_spend.block_height,
            'difficulty': calculate_new_difficulty(new_spend)
        }
        
        # Start farming for new round
        start_farming_round(new_challenge)
    
    # Subscribe to distributor coin spends
    subscribe_to_coin_spends(
        get_rewards_distributor_coin_id(),
        on_new_distributor_spend
    )

Rewards Distributor Coin

Competitive Spend Mechanism

The Rewards Distributor coin implements a competitive proof-of-space puzzle:

class RewardsDistributorPuzzle:
    def __init__(self):
        self.puzzle_conditions = {
            'valid_proof_of_space': True,
            'meets_difficulty_target': True,
            'valid_validation_package': True,
            'correct_reward_distribution': True
        }
    
    def verify_solution(self, solution):
        """
        Verify the farmer's solution to spend the coin
        """
        # 1. Extract components
        proof_of_space = solution['proof_of_space']
        validation_package = solution['validation_package']
        challenge_hash = get_last_distributor_spend_hash()
        
        # 2. Verify proof of space quality
        quality = calculate_quality(
            proof_of_space,
            challenge_hash
        )
        
        required_iters = calculate_iterations(quality, current_difficulty)
        if required_iters > MAX_ITERATIONS:
            return False  # Proof doesn't meet difficulty
            
        # 3. Verify PlotCoin validations
        farmer_key = get_farmer_key_from_proof(proof_of_space)
        expected_plotcoins = select_plotcoins_for_validator(
            challenge_hash,
            farmer_key
        )
        
        if not verify_plotcoin_validations(validation_package, expected_plotcoins):
            return False
            
        # 4. Verify reward distributions
        distributions = solution['reward_distributions']
        if not verify_reward_calculations(validation_package, distributions):
            return False
            
        # 5. Create next distributor coin
        create_next_distributor_coin(
            solution['next_puzzle_hash'],
            calculate_next_difficulty()
        )
        
        return True

Dynamic Difficulty Adjustment

def calculate_next_difficulty(last_spend):
    """
    Adjust difficulty to maintain ~16 minute validation intervals
    Similar to Chia's difficulty adjustment
    """
    blocks_elapsed = current_height() - last_spend.height
    target_blocks = 60  # ~16 minutes at 16s/block
    
    current_difficulty = last_spend.difficulty
    
    # Calculate adjustment factor
    if blocks_elapsed < target_blocks * 0.5:
        # Too fast - increase difficulty
        adjustment = min(2.0, target_blocks / blocks_elapsed)
        new_difficulty = int(current_difficulty * adjustment)
    elif blocks_elapsed > target_blocks * 2:
        # Too slow - decrease difficulty  
        adjustment = max(0.5, target_blocks / blocks_elapsed)
        new_difficulty = int(current_difficulty * adjustment)
    else:
        # Close to target - minor adjustment
        adjustment = target_blocks / blocks_elapsed
        new_difficulty = int(current_difficulty * adjustment)
    
    # Apply bounds
    return max(MIN_DIFFICULTY, min(MAX_DIFFICULTY, new_difficulty))

def calculate_iterations_required(quality, difficulty):
    """
    Calculate iterations based on plot quality and difficulty
    """
    # Similar to Chia's proof quality calculation
    return int(difficulty / quality)

Security Properties

DDOS Prevention

def prevent_validation_ddos():
    """
    Competition + deterministic assignment prevents DDOS
    """
    # 1. Only ONE farmer wins each round
    # - Not thousands of validators hitting network simultaneously
    # - Single winner validates and distributes rewards
    
    # 2. Winner's PlotCoin assignment is deterministic
    winner_pubkey = get_winner_pubkey_from_proof(winning_proof)
    assigned_plotcoins = select_plotcoins_for_validator(
        challenge_hash,
        winner_pubkey
    )
    
    # 3. Fast validation window
    # - Winner must validate quickly to claim reward
    # - Limited time window prevents prolonged network stress
    
    # 4. Natural rate limiting
    # - ~16 minute intervals between validation rounds
    # - Network has time to recover between rounds
    
    return {
        'validators_per_round': 1,  # Only winner validates
        'validation_frequency': '~16 minutes',
        'plotcoins_per_round': 'max 10',
        'network_load': 'minimal and predictable'
    }

Sybil Resistance

• Proof of Space: Physical storage requirement (Chia plots)
• Active farming: Must maintain active participation in Chia network
• Economic cost: Plot creation and storage costs prevent spam
• No advantage: Multiple identities require proportional plot investment

Freshness Guarantees

• Block hash seed: Uses last rewards distributor spend for fresh randomness
• Validation chain: Each spend seeds the next validation round
• Time limits: Validations expire after N blocks

Economic Model

Reward Distribution

def distribute_rewards(validation_package):
    total_reward = get_epoch_reward_amount()
    
    # Validator gets base fee
    validator_fee = total_reward * VALIDATOR_FEE_RATE  # TBD
    
    # Remaining goes to validated storage providers
    provider_rewards = total_reward - validator_fee
    
    # Distribute proportionally to valid providers
    valid_providers = extract_providers(validation_package.validations)
    per_provider = provider_rewards / len(valid_providers)
    
    return {
        'validator': {
            'address': validation_package.validator,
            'amount': validator_fee
        },
        'providers': [
            {'address': p, 'amount': per_provider}
            for p in valid_providers
        ]
    }

Incentive Alignment

Participant	Incentive	Behavior
Validators	Earn fees	Perform honest validation
Storage Providers	Earn rewards	Maintain available storage
Network	Security	Distributed validation load

Implementation Considerations

Transition Plan

1. Phase 1: Parallel operation with current validators
2. Phase 2: Gradual shift to permissionless model
3. Phase 3: Full permissionless validation

Integration with Chia Client

class ChiaClientDIGExtension:
    """
    Extension to standard Chia farming client
    """
    def __init__(self, chia_farmer):
        self.farmer = chia_farmer
        self.dig_enabled = True
        self.current_dig_challenge = None
        
    def on_new_signage_point(self, signage_point):
        """
        Called by Chia client for each signage point
        """
        # Normal Chia farming
        self.farmer.check_plots_for_chia(signage_point)
        
        # Parallel DIG farming
        if self.dig_enabled:
            self.check_plots_for_dig()
    
    def check_plots_for_dig(self):
        """
        Check if any plots can win DIG validation
        """
        if not self.current_dig_challenge:
            self.current_dig_challenge = get_current_dig_challenge()
            
        for plot in self.farmer.plots:
            # Check plot for DIG proof
            result = check_plot_for_dig_proof(
                plot, 
                self.current_dig_challenge['challenge_hash'],
                self.current_dig_challenge['difficulty']
            )
            
            if result['qualifies']:
                # We can win! Quickly validate and submit
                self.attempt_dig_validation(plot, result['proof'])
                
    def attempt_dig_validation(self, plot, proof):
        """
        Found winning proof - validate and claim rewards
        """
        # Create validation package
        validation_package = create_validation_package(
            self.current_dig_challenge['challenge_hash'],
            plot.plot_id
        )
        
        # Submit to network
        if race_to_spend_distributor(proof, validation_package):
            self.on_validation_success()

Requirements

requirements = {
    'chia_plots': 'Existing Chia plots (any size)',
    'chia_node': 'Running Chia full node',
    'dig_extension': 'DIG validation extension',
    'no_additional_hardware': True,
    'no_additional_energy': True
}

Benefits

Instant Network Effect

• 100,000+ farmers ready to validate on day one
• 35+ EiB of combined plot space for security
• Global distribution across all continents
• No recruitment needed - farmers can opt-in immediately

Zero Additional Cost

• Same plots work for both Chia and DIG
• No new hardware required
• No extra electricity consumption
• Pure profit for farmers from existing infrastructure

Proven Security Model

• Battle-tested Proof of Space from Chia
• Sybil resistant through real storage costs
• Deterministic PlotCoin assignment prevents gaming
• Difficulty adjustment maintains consistent validation times

Perfect Alignment

• Win-win for both Chia and DIG networks
• Farmers benefit from dual revenue streams
• Storage providers get reliable validation
• Users get decentralized, secure storage

Future Enhancements

Optimization Opportunities

1. Batch validation: Validate multiple epochs in one package
2. Proof aggregation: Combine multiple validators' proofs
3. Plot optimization: Enhanced rewards for larger farmers
4. Cross-chain validation: Validate storage on multiple chains
5. Pool protocol integration: Allow pool farmers to participate

Advanced Features

future_features = {
    'reputation_system': 'Track validator performance',
    'slashing_conditions': 'Penalize false validations',
    'plot_nft_integration': 'Use Chia Plot NFTs for enhanced verification',
    'pool_protocol': 'Allow pool farmers to validate collectively',
    'timelord_integration': 'Leverage Chia timelords for timing proofs',
    'compressed_plots': 'Support for Chia compressed plot formats'
}

Key Innovation: True Dual Farming

The breakthrough of this system is that farmers compete to win validation rounds using the same Proof of Space mechanism that secures Chia. Rather than just requiring farmers to prove they own plots, the system uses Chia's proven consensus mechanism where farmers race to find qualifying proofs. The first farmer to find a proof that meets the DIG difficulty target wins the right to:

1. Spend the Rewards Distributor coin
2. Validate up to 10 PlotCoins deterministically assigned to them
3. Claim validator rewards
4. Distribute payments to storage providers

This creates true dual farming where:

• Farmers check their plots for both Chia and DIG proofs simultaneously
• The same plot can win rewards on both networks
• No additional hardware, energy, or plots needed
• Instant bootstrap of 100,000+ potential validators

By integrating directly into Chia's farming client, this system leverages the entire Chia network's security and decentralization while creating a new revenue stream for farmers. The competitive race mechanism ensures consistent validation intervals (~16 minutes) through difficulty adjustment, similar to how Chia maintains consistent block times.