power_house 0.3.3

Deterministic proofs, portable .pha provenance, Rootprint graphs, and optional quorum networking.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

import copy
import json
import pathlib
import unittest

from power_house import (
    PowerHouseError,
    calculate_phx_fingerprint,
    create_artifact,
    equivalent,
    fork,
    merge,
    new_rootprint,
    verify_artifact,
    verify_rootprint,
)
from power_house.external import attach_external_proof, verify_external_attachments


ROOT = pathlib.Path(__file__).resolve().parents[3]
VECTORS = ROOT / "conformance" / "pha-v1"


class PowerHouseSdkTests(unittest.TestCase):
    def test_core_defaults_and_optional_epa_are_separate(self):
        artifact = create_artifact(
            {"source": "python"},
            "power-house/test/v1",
            {"claim": 7},
            {"accepted": True},
        )
        self.assertNotIn(
            "external_proof_attachments", artifact["embedded_proof"]
        )
        attached = attach_external_proof(
            artifact, "epa-1", "external/test/v1", {"proof": "opaque"}
        )
        self.assertEqual(
            artifact["phx_fingerprint"], attached["phx_fingerprint"]
        )
        verify_artifact(attached)
        verify_external_attachments(attached)

        attached["embedded_proof"]["external_proof_attachments"][0][
            "payload"
        ] = {"proof": "mutated"}
        verify_artifact(attached)
        with self.assertRaises(PowerHouseError):
            verify_external_attachments(attached)

    def test_rootprint_branching_ignores_epa(self):
        base = create_artifact({}, "power-house/test/v1", {}, {"value": 1})
        graph = new_rootprint("main", base)
        attached = attach_external_proof(
            base, "epa-1", "external/test/v1", {"proof": "opaque"}
        )
        left = fork(graph, "main", "left", attached)
        right = fork(graph, "main", "right", base)
        merge(graph, left, right, "merged", base)
        self.assertTrue(equivalent(graph, left, right))
        verify_rootprint(graph)

    def test_non_integer_numbers_are_rejected(self):
        with self.assertRaises(PowerHouseError):
            create_artifact({}, "power-house/test/v1", {}, {"value": 1.5})

    def test_rust_conformance_vectors(self):
        core = json.loads((VECTORS / "core-valid.pha").read_text())
        attached = json.loads((VECTORS / "core-with-epa.pha").read_text())
        graph = json.loads((VECTORS / "rootprint-valid.json").read_text())
        verify_artifact(core)
        verify_artifact(attached)
        verify_external_attachments(attached)
        verify_rootprint(graph)
        self.assertEqual(
            core["phx_fingerprint"], calculate_phx_fingerprint(core)
        )
        self.assertEqual(
            core["phx_fingerprint"], attached["phx_fingerprint"]
        )

        broken = copy.deepcopy(core)
        broken["embedded_proof"]["proof"]["accepted"] = False
        with self.assertRaises(PowerHouseError):
            verify_artifact(broken)


if __name__ == "__main__":
    unittest.main()