remove Parts class, make parts properties

Author: BenWestgate

README.md

@@ -11,7 +11,7 @@ Shamir-share interpolation helpers and helpers to build codex32 strings from see
 - Short checksum (13 chars) and long checksum (15 chars) support.
 - Construct codex32 strings from raw seed bytes via `from_seed`.
 - CRC-based default padding scheme for `from_seed`.
-- Parse codex32 strings and access parts via `Parts`.
+- Parse codex32 strings and access parts via properties.
 - Interpolate/recover shares via `interpolate_at`.
 - Default identifier is the bech32-encoded BIP32 fingerprint.
 

src/codex32/codex32.py

@@ -321,6 +321,31 @@ class Codex32String:
 
     def __init__(self, s=""):
         self.s = s
+        self.hrp, data = bech32_decode(self.s)
+        _, s = self.s.rsplit("1", 1)
+        if len(s) < 94 and len(s) > 44:
+            checksum_len = 13
+        elif len(s) >= 96 and len(s) < 125:
+            checksum_len = 15
+        else:
+            raise InvalidLength(f"{len(s)} must be 45-93 or 96 to 124")
+        threshold_char = s[0]
+        if threshold_char.isdigit() and threshold_char != "1":
+            k = int(threshold_char)
+        else:
+            raise InvalidThreshold(threshold_char)
+        self.k = k
+        self.ident = s[1:5]
+        self.share_index = s[5]
+        self.payload = s[6 : len(s) - checksum_len]
+        self.checksum = s[-checksum_len:]
+        if self.k == 0 and self.share_index.lower() != "s":
+            raise InvalidShareIndex(self.share_index + "must be 's' when k=0")
+        if not ms32_verify_checksum(data):
+            raise InvalidChecksum(f"string={s}")
+        incomplete_group = (len(self.payload) * 5) % 8
+        if incomplete_group > 4:
+            raise IncompleteGroup(str(incomplete_group))
 
     def __str__(self):
         return self.s
@@ -333,79 +358,44 @@ def __eq__(self, other):
     def __hash__(self):
         return hash(self.s)
 
-    def sanity_check(self):
-        """Perform sanity check on the codex32 string."""
-        parts = self.parts
-        incomplete_group = (len(parts.payload) * 5) % 8
-        if incomplete_group > 4:
-            raise IncompleteGroup(str(incomplete_group))
+    @property
+    def data(self):
+        """Return the payload data bytes."""
+        return bytes(convertbits(bech32_to_u5(self.payload), 5, 8, False))
 
     @classmethod
     def from_unchecksummed_string(cls, s, hrp="ms"):
         """Create Codex32String from unchecksummed string."""
-        hrp, data = bech32_decode(s, hrp=hrp)
+        _, data = bech32_decode(s, hrp=hrp)
         ret = cls(bech32_encode(data + ms32_create_checksum(data), hrp))
-        ret.sanity_check()
         return ret
 
     @classmethod
     def from_string(cls, s, hrp="ms"):
         """Create Codex32String from a codex32 string."""
-        _, data = bech32_decode(s, hrp=hrp)
-        if not ms32_verify_checksum(data):
-            raise InvalidChecksum(f"string={s}")
         ret = cls(s)
-        ret.sanity_check()
-        return ret
-
-    @property
-    def parts(self):
-        """Get parts of the codex32 string."""
-        hrp, s = self.s.rsplit("1", 1) if "1" in self.s else ("", self.s)
-        if len(s) < 94 and len(s) > 44:
-            checksum_len = 13
-        elif len(s) >= 96 and len(s) < 125:
-            checksum_len = 15
-        else:
-            raise InvalidLength(f"{len(s)} must be 45-93 or 96 to 124")
-        threshold_char = s[0]
-        if threshold_char.isdigit() and threshold_char != "1":
-            k = int(threshold_char)
-        else:
-            raise InvalidThreshold(threshold_char)
-        ret = Parts(
-            hrp=hrp,
-            k=k,
-            ident=s[1:5],
-            share_index=s[5],
-            payload=s[6 : len(s) - checksum_len],
-            checksum=s[-checksum_len:],
-        )
-        if ret.k == 0 and ret.share_index.lower() != "s":
-            raise InvalidShareIndex(ret.share_index + "must be 's' when k=0")
         return ret
 
     @classmethod
-    def interpolate_at(cls, shares, target):
+    def interpolate_at(cls, shares, target="s"):
         """Interpolate to a specific target share index."""
         indices = []
         ms32_shares = []
-        s0_parts = shares[0].parts
+        s0_parts = shares[0]
         if s0_parts.k > len(shares):
             raise ThresholdNotPassed(f"threshold={s0_parts.k}, n_shares={len(shares)}")
         for share in shares:
-            parts = share.parts
             if len(shares[0].s) != len(share.s):
                 raise MismatchedLength(f"{len(shares[0].s)}, {len(share.s)}")
-            if s0_parts.hrp != parts.hrp:
-                raise MismatchedHrp(f"{s0_parts.hrp}, {parts.hrp}")
-            if s0_parts.k != parts.k:
-                raise MismatchedThreshold(f"{s0_parts.k}, {parts.k}")
-            if s0_parts.ident != parts.ident:
-                raise MismatchedId(f"{s0_parts.ident}, {parts.ident}")
-            if parts.share_index in indices:
-                raise RepeatedIndex(parts.share_index)
-            indices.append(parts.share_index)
+            if s0_parts.hrp != share.hrp:
+                raise MismatchedHrp(f"{s0_parts.hrp}, {share.hrp}")
+            if s0_parts.k != share.k:
+                raise MismatchedThreshold(f"{s0_parts.k}, {share.k}")
+            if s0_parts.ident != share.ident:
+                raise MismatchedId(f"{s0_parts.ident}, {share.ident}")
+            if share.share_index in indices:
+                raise RepeatedIndex(share.share_index)
+            indices.append(share.share_index)
             ms32_shares.append(bech32_decode(share.s)[1])
         for i, share in enumerate(shares):
             if indices[i] == target:
@@ -432,45 +422,3 @@ def from_seed(cls, data, ident="", hrp="ms", k=0, share_idx="s", pad_val=None):
         combined = header + payload
         ret = bech32_encode(combined + ms32_create_checksum(combined), hrp)
         return cls(ret)
-
-
-class Parts:
-    """Class representing parts of a Codex32 string."""
-
-    # pylint: disable=too-many-arguments,too-many-positional-arguments
-    def __init__(self, hrp, k, ident, share_index, payload, checksum):
-        self.hrp = hrp
-        self.k = k
-        self.ident = ident
-        self.share_index = share_index
-        self.payload = payload
-        self.checksum = checksum
-
-    @property
-    def data(self):
-        """Get data from payload."""
-        return bytes(convertbits(bech32_to_u5(self.payload), 5, 8, False))
-
-    def __eq__(self, other):
-        if not isinstance(other, Parts):
-            return False
-        return (
-            self.hrp == other.hrp
-            and self.k == other.k
-            and self.ident == other.ident
-            and self.share_index == other.share_index
-            and self.payload == other.payload
-            and self.checksum == other.checksum
-        )
-
-    def __hash__(self):
-        return hash(
-            (
-                self.hrp,
-                self.k,
-                self.ident,
-                self.share_index,
-                self.payload,
-                self.checksum,
-            )
-        )

tests/test_bip93.py

@@ -32,15 +32,14 @@
 
 def test_parts():
     """Test Vector 1: parse a codex32 string into parts"""
-    c32 = Codex32String.from_string(VECTOR_1["secret_s"])
-    parts = c32.parts
-    assert parts.hrp == VECTOR_1["hrp"]
-    assert parts.k == VECTOR_1["k"]
-    assert parts.share_index == VECTOR_1["share_index"]
-    assert parts.ident == VECTOR_1["identifier"]
-    assert parts.payload == VECTOR_1["payload"]
-    assert parts.checksum == VECTOR_1["checksum"]
-    assert parts.data.hex() == VECTOR_1["secret_hex"]
+    c32 = Codex32String(VECTOR_1["secret_s"])
+    assert c32.hrp == VECTOR_1["hrp"]
+    assert c32.k == VECTOR_1["k"]
+    assert c32.share_index == VECTOR_1["share_index"]
+    assert c32.ident == VECTOR_1["identifier"]
+    assert c32.payload == VECTOR_1["payload"]
+    assert c32.checksum == VECTOR_1["checksum"]
+    assert c32.data.hex() == VECTOR_1["secret_hex"]
 
 
 def test_derive_and_recover():
@@ -52,16 +51,15 @@ def test_derive_and_recover():
     assert str(d) == VECTOR_2["derived_D"]
     s = Codex32String.interpolate_at([a, c], "S")
     assert str(s) == VECTOR_2["secret_S"]
-    assert s.parts.data.hex() == VECTOR_2["secret_hex"]
+    assert s.data.hex() == VECTOR_2["secret_hex"]
 
 
 def test_from_seed_and_interpolate_3_of_5():
     """Test Vector 3: encode secret share from seed and split 3-of-5"""
     seed = bytes.fromhex(VECTOR_3["secret_hex"])
     a = Codex32String.from_string(VECTOR_3["share_a"])
     c = Codex32String.from_string(VECTOR_3["share_c"])
-    parts = a.parts
-    s = Codex32String.from_seed(seed, parts.ident, parts.hrp, parts.k, pad_val=0)
+    s = Codex32String.from_seed(seed, a.ident, a.hrp, a.k, pad_val=0)
     assert str(s) == VECTOR_3["secret_s"]
     d = Codex32String.interpolate_at([s, a, c], "d")
     e = Codex32String.interpolate_at([s, a, c], "e")
@@ -70,9 +68,7 @@ def test_from_seed_and_interpolate_3_of_5():
     assert str(e) == VECTOR_3["derived_e"]
     assert str(f) == VECTOR_3["derived_f"]
     for pad_val in range(4):
-        s = Codex32String.from_seed(
-            seed, parts.ident, parts.hrp, parts.k, pad_val=pad_val
-        )
+        s = Codex32String.from_seed(seed, a.ident, a.hrp, a.k, pad_val=pad_val)
         assert str(s) == VECTOR_3["secret_s_alternates"][pad_val]
 
 
@@ -84,15 +80,15 @@ def test_from_seed_and_alternates():
             seed, hrp="ms", k=0, ident="leet", share_idx="s", pad_val=pad_v
         )
         assert str(s) == VECTOR_4["secret_s_alternates"][pad_v]
-        assert s.parts.data == list(seed) or s.parts.data == seed
+        assert s.data == list(seed) or s.data == seed
         # confirm all 16 encodings decode to same master data
 
 
 def test_long_string():
     """Test Vector 5: decode long codex32 secret and confirm secret bytes."""
     long_str = VECTOR_5["secret_s"]
     long_seed = Codex32String.from_string(long_str)
-    assert long_seed.parts.data.hex() == VECTOR_5["secret_hex"]
+    assert long_seed.data.hex() == VECTOR_5["secret_hex"]
 
 
 # pylint: disable=missing-function-docstring
@@ -105,7 +101,7 @@ def test_invalid_bad_checksums():
 def test_wrong_checksums_or_length():
     for chk in WRONG_CHECKSUMS:
         with pytest.raises((InvalidChecksum, InvalidLength)):
-            Codex32String.from_string(chk)
+            Codex32String(chk)
 
 
 def test_invalid_improper_length():
@@ -129,7 +125,7 @@ def test_invalid_threshold():
 def test_invalid_prefix_or_separator():
     for chk in INVALID_PREFIX_OR_SEPARATOR:
         try:
-            Codex32String.from_string(chk)
+            Codex32String(chk)
             assert False, f"Accepted invalid HRP/separator in: {chk}"
         except (MismatchedHrp, SeparatorNotFound):
             pass