Plot Ownership Proof

💜 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

The Plot Ownership Proof demonstrates ownership of a specific plot through digital signatures. This proof uses Chia DataLayer signatures for optimal performance and makes all plot components public to enable subsequent verification steps.

Technical Specification

Proof Structure

interface PlotOwnershipProof {
  // Public inputs
  plotId: bytes32;         // Plot identifier
  publicKey: bytes32;      // Owner's public key
  merkleRoot: bytes32;     // Plot data commitment
  difficulty: uint32;      // Achieved difficulty
  blockHeight: uint32;     // Chia anchor block
  blockHash: bytes32;      // Chia anchor hash
  
  // Proof
  signature: bytes64;      // DataLayer signature
  signedMessage: bytes32;  // Message hash
}

Design Rationale

Digital Signatures vs Zero-Knowledge:

• Generation: ~5ms vs ~500ms
• Verification: ~0.5ms vs ~5ms
• Proof size: 64 bytes vs 256 bytes
• No trusted setup required
• Standard cryptographic primitive

Public Components: All plot components are public inputs, enabling:

• Independent plotId verification
• Merkle root for data inclusion proofs
• Transparent difficulty claims
• Blockchain anchoring validation

Proof Generation

Algorithm

def generate_plot_ownership_proof(plot_data, private_key):
    # Construct message from all components
    message_components = [
        plot_data.plotId,
        plot_data.publicKey,
        plot_data.merkleRoot,
        plot_data.difficulty.to_bytes(4),
        plot_data.blockHeight.to_bytes(4),
        plot_data.blockHash
    ]
    
    # Hash for signing
    signed_message = sha256(concat(message_components))
    
    # Generate Chia DataLayer signature
    signature = sign_message(signed_message, private_key)
    
    return PlotOwnershipProof(
        plotId=plot_data.plotId,
        publicKey=plot_data.publicKey,
        merkleRoot=plot_data.merkleRoot,
        difficulty=plot_data.difficulty,
        blockHeight=plot_data.blockHeight,
        blockHash=plot_data.blockHash,
        signature=signature,
        signedMessage=signed_message
    )

PlotId Construction

plotId = Poseidon(
    publicKey ||
    merkleRoot ||
    difficulty ||
    blockHeight ||
    blockHash
)

Verification Process

Algorithm

def verify_plot_ownership(proof):
    # Step 1: Verify plotId construction
    expected_plot_id = Poseidon(
        proof.publicKey,
        proof.merkleRoot,
        proof.difficulty,
        proof.blockHeight,
        proof.blockHash
    )
    
    if proof.plotId != expected_plot_id:
        return False, "Invalid plotId construction"
    
    # Step 2: Reconstruct message
    expected_message = sha256(concat([
        proof.plotId,
        proof.publicKey,
        proof.merkleRoot,
        proof.difficulty.to_bytes(4),
        proof.blockHeight.to_bytes(4),
        proof.blockHash
    ]))
    
    if proof.signedMessage != expected_message:
        return False, "Message mismatch"
    
    # Step 3: Verify signature
    return verify_signature(
        proof.signature,
        proof.publicKey,
        proof.signedMessage
    ), None

Security Properties

Information Disclosure

Public:

• Plot identifier and all components
• Owner's public key
• Merkle root (enables data proofs)
• Difficulty achieved
• Blockchain anchoring

Private:

• Owner's private key

Attack Resistance

Plot Theft Prevention:

Attacker cannot claim Alice's plot:
- Signature must verify with claimed publicKey
- Cannot forge signature without privateKey
- PlotId bound to specific publicKey

Component Forgery Prevention:

Cannot modify individual components:
- All components signed together
- PlotId formula enforces consistency
- Blockchain anchoring provides temporal proof

Integration

PlotCoin Structure

interface PlotCoin {
  plotId: bytes32;
  proofPackage: {
    plotOwnership: PlotOwnershipProof;
    // Other proofs...
  };
}

Verification Flow

1. Extract plot ownership proof from PlotCoin
2. Verify plotId construction formula
3. Verify DataLayer signature
4. Use public merkleRoot for data inclusion verification

Performance Metrics

Operation	Time	Size
Generation	~5ms	-
Verification	~0.5ms	-
Proof size	-	200 bytes
Signature only	-	64 bytes

Implementation Notes

Chia DataLayer Signatures

• Uses BLS12-381 curve
• Compatible with Chia ecosystem
• Hardware wallet support
• Aggregatable for batch verification

Constant-Time Operations

• Use constant-time comparison for security
• Prevent timing attacks on verification

Summary

The Plot Ownership Proof provides efficient ownership verification through digital signatures while making all plot components public. This transparency enables subsequent data inclusion proofs and maintains optimal performance characteristics for the DIG Network's high-throughput requirements.