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

proofnest-0.2.0.dist-info/RECORD

@@ -1,45 +0,0 @@
-./.gitignore,sha256=jTP1a-5WZxB6VIjQDxnlgi21WAsvcRKZHqgzK6RoCaE,481
-./AUDIT_GPT4o_2026-02-03.md,sha256=SIb0DTL8fgY8nDlFGCreUeBLsp9qNeAntls_dW2ImxY,2100
-./AUDIT_GPT52_2026-02-03.md,sha256=sWC871lqSWdRYQdRK9Tp1uVKn2tbvr2V3hmb9GpT4Vk,4527
-./AUDIT_GPT52_FULL_2026-02-03.md,sha256=gRG63eJLbUehRHzm76diJoWzgBufMSP9gx-BzhWyhQw,3192
-./AUDIT_GPT52_ROUND2_2026-02-03.md,sha256=PWjsbcFCUmljk6aKQ4qFYgxJHcaJKqTDNXSRKr3BGKM,2037
-./LICENSE,sha256=kJZdHD45cIKBd-xdBBGmxgesVMsUGFYKfPOQlHAFOZw,1071
-./PKG-INFO,sha256=HKa30HTILzRbUbM8ELCsqZIbtsEkWB2ga3Ny2wofLBg,5926
-./README.md,sha256=slBddYIxAp7i-s0HA3QKQ5XvJ5YTqVy637_0CF6aO44,4277
-./__init__.py,sha256=wkkzIxUYFN30mixtvNSX66wU7iW7bp7pngRcI7Q-YY4,2760
-./anchor.py,sha256=FRLy2nzDq0HJ9rT7J1GgOLcYynFY0ZhC-4i9RiuinmA,12160
-./api.py,sha256=J6IFtQPb_kixwRp4H_CwaAQoxEx-IZMmd04PU9qjATM,24901
-./blockchain.py,sha256=AoJXr8SeF5O7mCFg-DdpNvt0Io_Oi3hjowiMAPOLs1Q,12319
-./cli.py,sha256=XfQktB8e329cPGxu5qE11IVmY16PkkwjEcrpcsuPWgI,12497
-./consensus.py,sha256=U5UZy-bJRUQfk8U4e2vp1AzzTk-PrlzMsOnuEcGjQjo,13929
-./demo.py,sha256=6SAO6PIwQ6kOaS4a8vKe7RXMEnYrC0qaWxRQzUmmHJQ,4567
-./did_registry.py,sha256=9DXoTYfkUfuwp46QuzHNVpGZ2It_4Gits64SZ_REaqE,13404
-./network.py,sha256=4Wd1_-cgfvo47oiop-SCc662BsiFQLQZ_ELPPgEdZ6U,20992
-./proof.py,sha256=wRf5c5uEE3ALajCc_XSiVWdunoB26ARxr-hTqgrjeDM,37800
-./pyproject.toml,sha256=8rQlJr1iSmix1pXTFp6JUhT1Ry0rW6sb2wSJ223L_QY,2041
-./staking.py,sha256=T7iOdrWHCfvTocmeLejnHZ3SOVPgXEFJGkwmJX-ZcR0,16150
-./storage.py,sha256=bUKHybjnDpIIqHNkbItRBlQrrRZIfTGVRIeAvYAePaQ,19836
-./.planning/PROJECT.md,sha256=kLc52MDDFlCoBk4Gz7V2nFhPcRAyO1dhcmf2DVJhICU,4274
-./.planning/ROADMAP.md,sha256=XcxnUeEd8V9nFmxsZzOzU3iiSQR6m4-vbOPlFgipV8Y,4867
-./.planning/STATE.md,sha256=1rnqSvmyO0bwdyV1pvdf3La1z2NNDN_IwQ9FXTwifiQ,2184
-./.planning/config.json,sha256=CjZFWDey7cSl02ASBg8gVhs6a7CqOLwQmYlncmMFXX8,446
-./.planning/quick/001-artikkel-proofnest-vs-moltbook/001-PLAN.md,sha256=nqakgoBat0nCHvT0qoNbJFyroa4nRXHXRzc2r0knBsw,6623
-./.planning/quick/001-artikkel-proofnest-vs-moltbook/001-SUMMARY.md,sha256=d8VE1rarKhOUiCoUg_a6n-Lm3C5LhpXerAAqG2ixVQU,2431
-./.planning/quick/002-twitter-thread-proofnest-moltbook/002-PLAN.md,sha256=EXb7-TWgDu474iziCaBv9hKQ7hCsReGtUB1CK-JQsso,1524
-./.planning/quick/002-twitter-thread-proofnest-moltbook/002-SUMMARY.md,sha256=24ACIVpluXv_n_MPhA4rJDkYx_1ZlmOdPLADobVDZD8,1572
-./.planning/research/ARCHITECTURE.md,sha256=qnbZwYtaY8uhJF3mbGmRXLiNNP1WRhgpOz1pXBJ4gig,20215
-./.planning/research/FEATURES.md,sha256=UFcq3ED4P_lJfvL2eKM8856NGXxiqL_C6KOQE9RJp1g,10727
-./.planning/research/PITFALLS.md,sha256=6va5ieYb_RbH4c3PDAId7jVE9_AsXD9VXxKNzGz8HjI,19900
-./.planning/research/STACK.md,sha256=Y0YbrWRDCPXTk5kXmOLMN-hdrVlXEnsLHggwJopWENI,13833
-./.planning/research/SUMMARY.md,sha256=B6bEweIRqUDTx3r0pNrIhLWHBOhE5AfPXwsyDIe5ZpU,21686
-./content/articles/proofnest-vs-moltbook-en.md,sha256=IV_7YwCKiqaXwrkF4mcAc04pvS_GiWu0bNAQlXrmsNc,10121
-./content/social/twitter-thread-001.md,sha256=VYZ-4oZiF5aXsS0IiRz-3_0ZtPXSXVifvK_EXQApg1E,3228
-./tests/test_api.py,sha256=67XoGcgqdV26KdBvqL67oAvGmHo1ZlSNLZt4SlQDrlQ,9141
-./tests/test_did_registry.py,sha256=ehisZce4hu9QMur0_0mLC3uV0SVbSNHp2N4GDJAv8oE,6062
-./tests/test_proof.py,sha256=2c12YZfmVTnKEemwRPCAbN5w6GpbrFeuwB5PRVddO-Y,8919
-./tests/test_staking.py,sha256=MlcNnmZxkLNXUbibEq2DSKCZtVc_lllFDmKOEWkkZCQ,5852
-proofnest-0.2.0.dist-info/METADATA,sha256=HKa30HTILzRbUbM8ELCsqZIbtsEkWB2ga3Ny2wofLBg,5926
-proofnest-0.2.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-proofnest-0.2.0.dist-info/entry_points.txt,sha256=U2_jDn1Eg8j5Z3hQDks3CJ7qbe9auBsehyKT5RcGW-w,49
-proofnest-0.2.0.dist-info/licenses/LICENSE,sha256=kJZdHD45cIKBd-xdBBGmxgesVMsUGFYKfPOQlHAFOZw,1071
-proofnest-0.2.0.dist-info/RECORD,,

tests/test_api.py

@@ -1,270 +0,0 @@
-"""
-Tests for PROOFNEST API.
-"""
-
-import pytest
-from fastapi.testclient import TestClient
-import sys
-import os
-
-# Add parent to path
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-from api import app, API_KEY
-
-
-@pytest.fixture
-def client():
-    """Create test client"""
-    return TestClient(app)
-
-
-@pytest.fixture
-def auth_headers():
-    """Authentication headers for protected endpoints"""
-    return {"X-API-Key": API_KEY}
-
-
-class TestHealth:
-    """Test health endpoints"""
-
-    def test_health(self, client):
-        """Test health endpoint"""
-        response = client.get("/health")
-        assert response.status_code == 200
-        data = response.json()
-        assert data["status"] == "ok"
-
-    def test_root(self, client):
-        """Test root endpoint"""
-        response = client.get("/")
-        assert response.status_code == 200
-        data = response.json()
-        assert "ProofNest" in data["name"]
-
-
-class TestIdentities:
-    """Test identity endpoints"""
-
-    def test_create_identity(self, client, auth_headers):
-        """Test creating an identity"""
-        response = client.post("/v1/identities", json={
-            "identity_type": "agent",
-            "name": "Test Agent"
-        }, headers=auth_headers)
-        assert response.status_code == 200
-        data = response.json()
-        assert data["did"].startswith("did:pn:agent:")
-        assert data["name"] == "Test Agent"
-
-    def test_list_identities(self, client, auth_headers):
-        """Test listing identities"""
-        # Create one first
-        client.post("/v1/identities", json={"identity_type": "agent"}, headers=auth_headers)
-
-        response = client.get("/v1/identities")
-        assert response.status_code == 200
-        data = response.json()
-        assert "count" in data
-        assert "identities" in data
-
-
-class TestProofs:
-    """Test proof endpoints"""
-
-    def test_create_proof(self, client, auth_headers):
-        """Test creating a proof"""
-        # First create identity
-        identity = client.post("/v1/identities", json={
-            "identity_type": "agent"
-        }, headers=auth_headers).json()
-
-        # Then create proof
-        response = client.post("/v1/proofs", json={
-            "issuer_did": identity["did"],
-            "claim": "Test claim",
-            "proof_type": "CLAIM"
-        }, headers=auth_headers)
-        assert response.status_code == 200
-        data = response.json()
-        assert data["proof_id"].startswith("proof:")
-        assert data["is_valid"] is True
-
-    def test_get_proof(self, client, auth_headers):
-        """Test getting a proof"""
-        # Create identity and proof
-        identity = client.post("/v1/identities", json={
-            "identity_type": "agent"
-        }, headers=auth_headers).json()
-
-        proof = client.post("/v1/proofs", json={
-            "issuer_did": identity["did"],
-            "claim": "Get test",
-            "proof_type": "CLAIM"
-        }, headers=auth_headers).json()
-
-        # Get it (public endpoint - no auth needed)
-        response = client.get(f"/v1/proofs/{proof['proof_id']}")
-        assert response.status_code == 200
-
-    def test_verify_proof(self, client, auth_headers):
-        """Test verifying a proof"""
-        # Create identity and proof
-        identity = client.post("/v1/identities", json={
-            "identity_type": "agent"
-        }, headers=auth_headers).json()
-
-        proof = client.post("/v1/proofs", json={
-            "issuer_did": identity["did"],
-            "claim": "Verify test",
-            "proof_type": "CLAIM"
-        }, headers=auth_headers).json()
-
-        # Verify (public endpoint - no auth needed)
-        response = client.post(f"/v1/proofs/{proof['proof_id']}/verify")
-        assert response.status_code == 200
-        data = response.json()
-        assert data["is_valid"] is True
-
-
-class TestValidators:
-    """Test validator endpoints"""
-
-    def test_add_validator(self, client, auth_headers):
-        """Test adding a validator"""
-        response = client.post("/v1/validators", headers=auth_headers)
-        assert response.status_code == 200
-        data = response.json()
-        assert data["did"].startswith("did:pn:validator:")
-        assert data["stake"] == 1000
-
-    def test_list_validators(self, client, auth_headers):
-        """Test listing validators"""
-        # Add one first
-        client.post("/v1/validators", headers=auth_headers)
-
-        response = client.get("/v1/validators")
-        assert response.status_code == 200
-        data = response.json()
-        assert "count" in data
-        assert "validators" in data
-
-
-class TestConsensus:
-    """Test consensus flow"""
-
-    def test_full_consensus_flow(self, client, auth_headers):
-        """Test complete consensus flow"""
-        # 1. Create identity
-        identity = client.post("/v1/identities", json={
-            "identity_type": "agent"
-        }, headers=auth_headers).json()
-
-        # 2. Create proof
-        proof = client.post("/v1/proofs", json={
-            "issuer_did": identity["did"],
-            "claim": "Consensus test",
-            "proof_type": "WORK"
-        }, headers=auth_headers).json()
-        proof_id = proof["proof_id"]
-
-        # 3. Add validators
-        v1 = client.post("/v1/validators", headers=auth_headers).json()
-
-        # 4. Submit to consensus
-        submit = client.post(f"/v1/proofs/{proof_id}/submit-consensus", headers=auth_headers)
-        assert submit.status_code == 200
-
-        # 5. Vote (single validator with quorum_threshold=1 for test)
-        vote1 = client.post(f"/v1/proofs/{proof_id}/vote", json={
-            "proof_id": proof_id,
-            "validator_did": v1["did"],
-            "approve": True
-        }, headers=auth_headers)
-        assert vote1.status_code == 200
-        # With 1 validator, quorum is reached immediately
-        vote_data = vote1.json()
-        assert vote_data["vote"] == "APPROVE"
-        # Quorum may be reached depending on threshold
-        if vote_data.get("quorum_reached"):
-            assert vote_data.get("consensus_state") in ["ACCEPTED", "FINALIZED"]
-
-
-class TestChain:
-    """Test blockchain endpoints"""
-
-    def test_chain_status(self, client):
-        """Test chain status"""
-        response = client.get("/v1/chain/status")
-        assert response.status_code == 200
-        data = response.json()
-        assert "chain_id" in data
-        assert "height" in data
-
-    def test_chain_validators(self, client):
-        """Test chain validators"""
-        response = client.get("/v1/chain/validators")
-        assert response.status_code == 200
-        data = response.json()
-        assert "validators" in data
-
-
-class TestAuthentication:
-    """Test API authentication (GPT-5.2 audit fix)"""
-
-    def test_unauthenticated_create_identity_rejected(self, client):
-        """Verify unauthenticated identity creation is rejected"""
-        response = client.post("/v1/identities", json={
-            "identity_type": "agent"
-        })
-        assert response.status_code == 401
-        assert "Missing API key" in response.json()["detail"]
-
-    def test_unauthenticated_create_proof_rejected(self, client, auth_headers):
-        """Verify unauthenticated proof creation is rejected"""
-        # First create identity (authenticated)
-        identity = client.post("/v1/identities", json={
-            "identity_type": "agent"
-        }, headers=auth_headers).json()
-
-        # Try to create proof without auth
-        response = client.post("/v1/proofs", json={
-            "issuer_did": identity["did"],
-            "claim": "Test",
-            "proof_type": "CLAIM"
-        })
-        assert response.status_code == 401
-
-    def test_invalid_api_key_rejected(self, client):
-        """Verify invalid API key is rejected"""
-        response = client.post("/v1/identities", json={
-            "identity_type": "agent"
-        }, headers={"X-API-Key": "invalid-key"})
-        assert response.status_code == 403
-        assert "Invalid API key" in response.json()["detail"]
-
-    def test_public_endpoints_no_auth_needed(self, client, auth_headers):
-        """Verify public endpoints work without authentication"""
-        # Create some data first (authenticated)
-        identity = client.post("/v1/identities", json={
-            "identity_type": "agent"
-        }, headers=auth_headers).json()
-
-        proof = client.post("/v1/proofs", json={
-            "issuer_did": identity["did"],
-            "claim": "Public test",
-            "proof_type": "CLAIM"
-        }, headers=auth_headers).json()
-
-        # These should work without auth
-        assert client.get("/").status_code == 200
-        assert client.get("/health").status_code == 200
-        assert client.get("/v1/identities").status_code == 200
-        assert client.get(f"/v1/identities/{identity['did']}").status_code == 200
-        assert client.get("/v1/proofs").status_code == 200
-        assert client.get(f"/v1/proofs/{proof['proof_id']}").status_code == 200
-        assert client.get("/v1/chain/status").status_code == 200
-
-
-if __name__ == "__main__":
-    pytest.main([__file__, "-v"])

tests/test_did_registry.py

@@ -1,206 +0,0 @@
-"""
-Tests for DID Registry (GPT-5.2 audit - key rotation support)
-"""
-
-import pytest
-import sys
-import os
-import secrets
-
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-from did_registry import (
-    DIDDocument,
-    DIDRegistry,
-    VerificationMethod,
-    KeyPurpose,
-    KeyStatus,
-)
-
-
-class TestDIDDocument:
-    """Test DID Document operations"""
-
-    def test_create_document(self):
-        """Test creating a DID Document with initial key"""
-        pk = secrets.token_bytes(1952)
-        did = "did:pn:agent:test123"
-
-        doc = DIDDocument.create(did, pk)
-
-        assert doc.id == did
-        assert len(doc.verification_methods) == 1
-        assert doc.verification_methods[0].status == KeyStatus.ACTIVE
-
-    def test_create_with_recovery_key(self):
-        """Test creating a DID Document with recovery key"""
-        pk = secrets.token_bytes(1952)
-        recovery_pk = secrets.token_bytes(1952)
-        did = "did:pn:agent:test456"
-
-        doc = DIDDocument.create(did, pk, recovery_public_key=recovery_pk)
-
-        assert len(doc.verification_methods) == 2
-        assert len(doc.get_recovery_keys()) == 1
-
-    def test_add_key(self):
-        """Test adding a new key"""
-        pk1 = secrets.token_bytes(1952)
-        pk2 = secrets.token_bytes(1952)
-        did = "did:pn:agent:test789"
-
-        doc = DIDDocument.create(did, pk1)
-        initial_version = doc.version
-
-        doc.add_key(pk2, "Dilithium3VerificationKey2024", [KeyPurpose.ASSERTION])
-
-        assert len(doc.verification_methods) == 2
-        assert doc.version > initial_version
-
-    def test_key_rotation(self):
-        """Test key rotation (revoke old, add new)"""
-        pk1 = secrets.token_bytes(1952)
-        pk2 = secrets.token_bytes(1952)
-        did = "did:pn:agent:rotation_test"
-
-        doc = DIDDocument.create(did, pk1)
-        old_key_id = doc.verification_methods[0].id
-
-        # Rotate
-        new_key = doc.rotate_key(old_key_id, pk2, "Dilithium3VerificationKey2024")
-
-        # Old key should be revoked
-        old_key = doc.get_key(old_key_id)
-        assert old_key.status == KeyStatus.REVOKED
-
-        # New key should be active
-        assert new_key.status == KeyStatus.ACTIVE
-
-        # Only one active auth key
-        assert len(doc.get_active_keys(KeyPurpose.AUTHENTICATION)) == 1
-
-    def test_revoke_key(self):
-        """Test key revocation"""
-        pk = secrets.token_bytes(1952)
-        did = "did:pn:agent:revoke_test"
-
-        doc = DIDDocument.create(did, pk)
-        key_id = doc.verification_methods[0].id
-
-        result = doc.revoke_key(key_id)
-
-        assert result is True
-        assert doc.get_key(key_id).status == KeyStatus.REVOKED
-
-    def test_to_dict(self):
-        """Test W3C DID Document serialization"""
-        pk = secrets.token_bytes(1952)
-        did = "did:pn:agent:serialize_test"
-
-        doc = DIDDocument.create(did, pk)
-        d = doc.to_dict()
-
-        assert "@context" in d
-        assert d["id"] == did
-        assert "verificationMethod" in d
-        assert "authentication" in d
-
-
-class TestDIDRegistry:
-    """Test DID Registry operations"""
-
-    def test_register_and_resolve(self):
-        """Test registering and resolving a DID"""
-        registry = DIDRegistry()
-        pk = secrets.token_bytes(1952)
-        did = "did:pn:agent:registry_test"
-
-        doc = DIDDocument.create(did, pk)
-        result = registry.register(doc)
-
-        assert result is True
-        resolved = registry.resolve(did)
-        assert resolved is not None
-        assert resolved.id == did
-
-    def test_no_duplicate_registration(self):
-        """Test that duplicate DIDs cannot be registered"""
-        registry = DIDRegistry()
-        pk = secrets.token_bytes(1952)
-        did = "did:pn:agent:duplicate_test"
-
-        doc = DIDDocument.create(did, pk)
-        registry.register(doc)
-
-        # Second registration should fail
-        result = registry.register(doc)
-        assert result is False
-
-    def test_update_document(self):
-        """Test updating a DID Document"""
-        registry = DIDRegistry()
-        pk1 = secrets.token_bytes(1952)
-        pk2 = secrets.token_bytes(1952)
-        did = "did:pn:agent:update_test"
-
-        doc = DIDDocument.create(did, pk1)
-        registry.register(doc)
-
-        # Add key and update
-        doc.add_key(pk2, "Dilithium3VerificationKey2024", [KeyPurpose.ASSERTION])
-        result = registry.update(doc)
-
-        assert result is True
-        resolved = registry.resolve(did)
-        assert len(resolved.verification_methods) == 2
-
-    def test_deactivate(self):
-        """Test DID deactivation"""
-        registry = DIDRegistry()
-        pk = secrets.token_bytes(1952)
-        did = "did:pn:agent:deactivate_test"
-
-        doc = DIDDocument.create(did, pk)
-        registry.register(doc)
-
-        result = registry.deactivate(did)
-
-        assert result is True
-        resolved = registry.resolve(did)
-        assert resolved.deactivated is True
-
-    def test_version_history(self):
-        """Test DID Document version history"""
-        registry = DIDRegistry()
-        pk1 = secrets.token_bytes(1952)
-        pk2 = secrets.token_bytes(1952)
-        did = "did:pn:agent:history_test"
-
-        doc = DIDDocument.create(did, pk1)
-        registry.register(doc)
-
-        # Update
-        doc.add_key(pk2, "Dilithium3VerificationKey2024", [KeyPurpose.ASSERTION])
-        registry.update(doc)
-
-        history = registry.get_history(did)
-        assert len(history) == 2
-
-    def test_verify_controller(self):
-        """Test controller verification"""
-        registry = DIDRegistry()
-        pk1 = secrets.token_bytes(1952)
-        pk2 = secrets.token_bytes(1952)
-        did = "did:pn:agent:verify_test"
-
-        doc = DIDDocument.create(did, pk1)
-        registry.register(doc)
-
-        # Valid controller
-        assert registry.verify_controller(did, pk1) is True
-        # Invalid controller
-        assert registry.verify_controller(did, pk2) is False
-
-
-if __name__ == "__main__":
-    pytest.main([__file__, "-v"])