proofnest 0.2.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

tests/test_proof.py

@@ -1,279 +0,0 @@
-"""
-Tests for PROOF primitive.
-"""
-
-import pytest
-import sys
-import os
-
-# Add parent to path
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-from proof import (
-    Proof, ProofType, Identity, Evidence, Signature,
-    Timestamp, Anchor, AnchorType, Consensus, ConsensusState,
-    SignatureAlgorithm
-)
-
-
-class TestIdentity:
-    """Test Identity generation and verification"""
-
-    def test_generate_agent_identity(self):
-        """Test generating an agent identity"""
-        identity, private_key = Identity.generate("agent")
-
-        assert identity.did.startswith("did:pn:agent:")
-        assert len(identity.public_key) > 0
-        assert identity.algorithm == SignatureAlgorithm.DILITHIUM3
-        assert len(private_key) > 0
-
-    def test_generate_validator_identity(self):
-        """Test generating a validator identity"""
-        identity, private_key = Identity.generate("validator")
-
-        assert identity.did.startswith("did:pn:validator:")
-        assert len(identity.public_key) > 0
-
-    def test_identity_uniqueness(self):
-        """Test that each identity is unique"""
-        id1, _ = Identity.generate("agent")
-        id2, _ = Identity.generate("agent")
-
-        assert id1.did != id2.did
-        assert id1.public_key != id2.public_key
-
-    def test_generate_hybrid_identity(self):
-        """Test generating a hybrid ML-DSA + Ed25519 identity (GPT-5.2 audit recommendation)"""
-        identity, private_key = Identity.generate("agent", SignatureAlgorithm.HYBRID_ML_DSA_ED25519)
-
-        assert identity.did.startswith("did:pn:agent:")
-        assert identity.algorithm == SignatureAlgorithm.HYBRID_ML_DSA_ED25519
-        # Hybrid public key = Dilithium (1952) + Ed25519 (32)
-        assert len(identity.public_key) == 1984
-        # Hybrid private key = Dilithium (~4000) + Ed25519 (32)
-        assert len(private_key) == 4032
-
-    def test_generate_ed25519_identity(self):
-        """Test generating an Ed25519 identity (transitional)"""
-        identity, private_key = Identity.generate("agent", SignatureAlgorithm.ED25519)
-
-        assert identity.did.startswith("did:pn:agent:")
-        assert identity.algorithm == SignatureAlgorithm.ED25519
-        assert len(identity.public_key) == 32  # Ed25519 public key size
-        assert len(private_key) == 32  # Ed25519 private key size
-
-
-class TestEvidence:
-    """Test Evidence creation"""
-
-    def test_create_from_data(self):
-        """Test creating evidence from raw data"""
-        data = b"Test evidence data"
-        evidence = Evidence.from_data(data)
-
-        assert evidence.content_hash is not None
-        assert "shake256:" in evidence.content_hash  # Uses SHAKE256 prefix
-        assert evidence.content_size == len(data)
-
-    def test_embedded_data(self):
-        """Test evidence with embedded data"""
-        data = b"Embedded content"
-        evidence = Evidence.from_data(data)
-
-        assert evidence.embedded == data
-        assert evidence.content_type == "application/octet-stream"
-
-
-class TestProof:
-    """Test PROOF creation and verification"""
-
-    def test_create_claim_proof(self):
-        """Test creating a basic CLAIM proof"""
-        issuer, private_key = Identity.generate("agent")
-
-        proof = Proof.create(
-            proof_type=ProofType.CLAIM,
-            claim="Test claim",
-            issuer=issuer,
-            private_key=private_key,
-        )
-
-        assert proof.proof_id.startswith("proof:")
-        assert proof.claim == "Test claim"
-        assert proof.issuer.did == issuer.did
-        assert proof.signature is not None
-        assert proof.verify() is True
-
-    def test_create_work_proof(self):
-        """Test creating a WORK proof"""
-        issuer, private_key = Identity.generate("agent")
-
-        proof = Proof.work(
-            issuer=issuer,
-            private_key=private_key,
-            description="Completed task",
-            result=b"Task output",
-        )
-
-        assert proof.proof_type == ProofType.WORK
-        assert proof.evidence is not None
-        assert proof.verify() is True
-
-    def test_create_identity_proof(self):
-        """Test creating an IDENTITY proof"""
-        issuer, private_key = Identity.generate("agent")
-
-        proof = Proof.identity(
-            issuer=issuer,
-            private_key=private_key,
-            name="Test Agent",
-            role="tester",
-        )
-
-        assert proof.proof_type == ProofType.IDENTITY
-        assert proof.subject is not None  # Subject is issuer for identity proof
-        assert proof.verify() is True
-
-    def test_proof_hash_stability(self):
-        """Test that proof hash is stable"""
-        issuer, private_key = Identity.generate("agent")
-
-        proof = Proof.create(
-            proof_type=ProofType.CLAIM,
-            claim="Stable claim",
-            issuer=issuer,
-            private_key=private_key,
-        )
-
-        hash1 = proof.compute_hash()
-        hash2 = proof.compute_hash()
-
-        assert hash1 == hash2
-        assert hash1 == proof.proof_id
-
-    def test_proof_chain(self):
-        """Test proof chaining"""
-        issuer, private_key = Identity.generate("agent")
-
-        proof1 = Proof.create(
-            proof_type=ProofType.CLAIM,
-            claim="First claim",
-            issuer=issuer,
-            private_key=private_key,
-        )
-
-        proof2 = Proof.create(
-            proof_type=ProofType.CLAIM,
-            claim="Second claim",
-            issuer=issuer,
-            private_key=private_key,
-            previous_proof=proof1.proof_id,
-        )
-
-        assert proof2.previous_proof == proof1.proof_id
-
-    def test_proof_to_dict(self):
-        """Test proof serialization to dict"""
-        issuer, private_key = Identity.generate("agent")
-
-        proof = Proof.create(
-            proof_type=ProofType.CLAIM,
-            claim="Serialization test",
-            issuer=issuer,
-            private_key=private_key,
-        )
-
-        d = proof.to_dict()
-
-        assert "proof_id" in d
-        assert "claim" in d
-        assert "proof_type" in d
-        assert "issuer" in d
-        assert "timestamp" in d
-
-    def test_hybrid_signature_proof(self):
-        """Test PROOF with hybrid ML-DSA + Ed25519 signature (GPT-5.2 audit recommendation)"""
-        issuer, private_key = Identity.generate("agent", SignatureAlgorithm.HYBRID_ML_DSA_ED25519)
-
-        proof = Proof.create(
-            proof_type=ProofType.CLAIM,
-            claim="Hybrid signature test",
-            issuer=issuer,
-            private_key=private_key,
-        )
-
-        assert proof.signature.algorithm == SignatureAlgorithm.HYBRID_ML_DSA_ED25519
-        # Verify MÕLEMAD allkirjad töötavad
-        assert proof.verify() is True
-        # Hybrid signature = Dilithium (~3293) + Ed25519 (64)
-        assert len(proof.signature.value) > 3000
-
-    def test_hybrid_signature_tamper_resistance(self):
-        """Test that tampering with hybrid-signed PROOF is detected"""
-        issuer, private_key = Identity.generate("agent", SignatureAlgorithm.HYBRID_ML_DSA_ED25519)
-
-        proof = Proof.create(
-            proof_type=ProofType.CLAIM,
-            claim="Original claim",
-            issuer=issuer,
-            private_key=private_key,
-        )
-
-        # Create tampered proof with different claim
-        tampered = Proof(
-            proof_id=proof.proof_id,
-            proof_type=proof.proof_type,
-            claim="TAMPERED claim",  # Modified!
-            issuer=proof.issuer,
-            signature=proof.signature,
-            timestamp=proof.timestamp,
-        )
-
-        # Original should verify
-        assert proof.verify() is True
-        # Tampered should fail (hash won't match)
-        assert tampered.verify() is False
-
-
-class TestTimestamp:
-    """Test Timestamp with nonce (replay protection)"""
-
-    def test_timestamp_has_nonce(self):
-        """Test that timestamp includes nonce for replay protection"""
-        ts = Timestamp.now()
-
-        assert ts.unix_time > 0
-        assert ts.nonce is not None
-        assert len(ts.nonce) > 0
-
-    def test_timestamp_uniqueness(self):
-        """Test that timestamps are unique even at same time"""
-        ts1 = Timestamp.now()
-        ts2 = Timestamp.now()
-
-        # Nonces should be different
-        assert ts1.nonce != ts2.nonce
-
-
-class TestConsensus:
-    """Test Consensus state"""
-
-    def test_consensus_state(self):
-        """Test consensus state creation"""
-        consensus = Consensus(
-            state=ConsensusState.PENDING,
-            quorum_threshold=0.67
-        )
-
-        assert consensus.state == ConsensusState.PENDING
-        assert consensus.quorum_threshold == 0.67
-
-    def test_consensus_accepted_state(self):
-        """Test accepted consensus state"""
-        consensus = Consensus(state=ConsensusState.ACCEPTED)
-        assert consensus.state == ConsensusState.ACCEPTED
-
-
-if __name__ == "__main__":
-    pytest.main([__file__, "-v"])

tests/test_staking.py

@@ -1,174 +0,0 @@
-"""
-Tests for Staking & Sybil Resistance (GPT-5.2 audit)
-"""
-
-import pytest
-import sys
-import os
-from decimal import Decimal
-
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-from staking import (
-    StakingRegistry,
-    ValidatorStake,
-    StakeRecord,
-    StakeType,
-    SlashReason,
-)
-
-
-class TestValidatorStake:
-    """Test validator stake operations"""
-
-    def test_create_validator(self):
-        """Test creating a validator with initial stake"""
-        validator = ValidatorStake(validator_did="did:pn:validator:test")
-        validator.add_reputation(100)
-
-        assert validator.validator_did == "did:pn:validator:test"
-        assert validator.reputation_score == 100
-        assert validator.total_stake == Decimal("100")
-
-    def test_voting_power_calculation(self):
-        """Test that voting power uses diminishing returns"""
-        v1 = ValidatorStake(validator_did="did:pn:validator:small")
-        v1.add_reputation(100)
-
-        v2 = ValidatorStake(validator_did="did:pn:validator:large")
-        v2.add_reputation(100)
-        # Add large economic stake
-        v2.stakes.append(StakeRecord(
-            stake_id="stake:1",
-            validator_did="did:pn:validator:large",
-            stake_type=StakeType.ESCROW,
-            amount=Decimal("10000"),
-            currency="USD",
-        ))
-
-        # Large validator should have more power, but not 100x more
-        ratio = float(v2.voting_power) / float(v1.voting_power)
-        assert ratio > 1.5  # Larger should have more power
-        assert ratio < 100  # But not proportionally more (diminishing returns)
-
-    def test_slash_reduces_stake(self):
-        """Test that slashing reduces effective stake"""
-        validator = ValidatorStake(validator_did="did:pn:validator:slashme")
-        validator.stakes.append(StakeRecord(
-            stake_id="stake:1",
-            validator_did="did:pn:validator:slashme",
-            stake_type=StakeType.ESCROW,
-            amount=Decimal("1000"),
-            currency="USD",
-        ))
-
-        initial_stake = validator.total_stake
-        validator.slash(SlashReason.DOUBLE_SIGN, Decimal("0.5"))
-
-        assert validator.total_stake < initial_stake
-        assert validator.total_stake == Decimal("500")
-
-    def test_jail_prevents_validation(self):
-        """Test that jailed validators cannot participate"""
-        validator = ValidatorStake(validator_did="did:pn:validator:jailed")
-        validator.add_reputation(500)
-
-        # Not jailed initially
-        assert validator.is_jailed is False
-
-        # Jail for 1 hour
-        validator.jail(3600)
-        assert validator.is_jailed is True
-
-        # Cannot unjail yet (time hasn't passed)
-        assert validator.unjail() is False
-
-
-class TestStakingRegistry:
-    """Test staking registry operations"""
-
-    def test_register_validator(self):
-        """Test registering a new validator"""
-        registry = StakingRegistry()
-        validator = registry.register_validator("did:pn:validator:new")
-
-        assert validator is not None
-        assert validator.validator_did == "did:pn:validator:new"
-
-    def test_minimum_stake_requirement(self):
-        """Test that minimum stake is required to validate"""
-        registry = StakingRegistry()
-
-        # Validator with no stake
-        registry.register_validator("did:pn:validator:poor")
-        assert registry.can_validate("did:pn:validator:poor") is False
-
-        # Validator with enough stake
-        v = registry.register_validator("did:pn:validator:rich")
-        v.add_reputation(200)
-        assert registry.can_validate("did:pn:validator:rich") is True
-
-    def test_reward_increases_reputation(self):
-        """Test that validation rewards increase reputation"""
-        registry = StakingRegistry()
-        v = registry.register_validator("did:pn:validator:worker")
-        v.add_reputation(100)  # Initial stake
-
-        initial_rep = v.reputation_score
-        registry.reward_validation("did:pn:validator:worker", "proof:123", True)
-
-        assert v.reputation_score > initial_rep
-
-    def test_slash_for_misbehavior(self):
-        """Test slashing for various violations"""
-        registry = StakingRegistry()
-        v = registry.register_validator("did:pn:validator:bad")
-        v.stakes.append(StakeRecord(
-            stake_id="stake:1",
-            validator_did="did:pn:validator:bad",
-            stake_type=StakeType.ESCROW,
-            amount=Decimal("1000"),
-            currency="USD",
-        ))
-
-        event = registry.slash_validator("did:pn:validator:bad", SlashReason.DOUBLE_SIGN)
-
-        assert event is not None
-        assert event.reason == SlashReason.DOUBLE_SIGN
-        assert v.is_jailed is True
-
-    def test_get_active_validators(self):
-        """Test getting only active validators"""
-        registry = StakingRegistry()
-
-        # Active validator
-        v1 = registry.register_validator("did:pn:validator:active")
-        v1.add_reputation(200)
-
-        # Jailed validator
-        v2 = registry.register_validator("did:pn:validator:jailed")
-        v2.add_reputation(200)
-        v2.jail(3600)
-
-        active = registry.get_active_validators()
-        assert len(active) == 1
-        assert active[0].validator_did == "did:pn:validator:active"
-
-    def test_voting_power_distribution(self):
-        """Test getting voting power for all active validators"""
-        registry = StakingRegistry()
-
-        v1 = registry.register_validator("did:pn:validator:a")
-        v1.add_reputation(300)
-
-        v2 = registry.register_validator("did:pn:validator:b")
-        v2.add_reputation(150)
-
-        powers = registry.get_voting_power_distribution()
-
-        assert len(powers) == 2
-        assert powers["did:pn:validator:a"] > powers["did:pn:validator:b"]
-
-
-if __name__ == "__main__":
-    pytest.main([__file__, "-v"])