refactored Prefixer to remove verify and derive methods. Functionality moved to Serder.

Removed redundant SerderKERI._verify() calls as its init defaults to calling ._verify

Author: SmithSamuelM

src/keri/core/coring.py

@@ -466,25 +466,6 @@ def __iter__(self):
 
 
 
-@dataclass(frozen=True)
-class NonTransCodex:
-    """
-    NonTransCodex is codex all non-transferable derivation codes
-    Only provide defined codes.
-    Undefined are left out so that inclusion(exclusion) via 'in' operator works.
-    """
-    Ed25519N: str = 'B'  # Ed25519 verification key non-transferable, basic derivation.
-    ECDSA_256k1N: str = '1AAA'  # ECDSA secp256k1 verification key non-transferable, basic derivation.
-    Ed448N: str = '1AAC'  # Ed448 non-transferable prefix public signing verification key. Basic derivation.
-    ECDSA_256r1N: str = "1AAI"  # ECDSA secp256r1 verification key non-transferable, basic derivation.
-
-    def __iter__(self):
-        return iter(astuple(self))
-
-
-NonTransDex = NonTransCodex()  # Make instance
-
-
 # When add new to DigCodes update Saider.Digests and Serder.Digests class attr
 @dataclass(frozen=True)
 class DigCodex:
@@ -574,7 +555,7 @@ class PreCodex:
     Undefined are left out so that inclusion(exclusion) via 'in' operator works.
     """
     Ed25519N:      str = 'B'  # Ed25519 verification key non-transferable, basic derivation.
-    Ed25519:       str = 'D'  # Ed25519 verification key basic derivation
+    Ed25519:       str = 'D'  # Ed25519 verification key, basic derivation.
     Blake3_256:    str = 'E'  # Blake3 256 bit digest self-addressing derivation.
     Blake2b_256:   str = 'F'  # Blake2b 256 bit digest self-addressing derivation.
     Blake2s_256:   str = 'G'  # Blake2s 256 bit digest self-addressing derivation.
@@ -586,6 +567,9 @@ class PreCodex:
     SHA2_512:      str = '0G'  # SHA2 512 bit digest self-addressing derivation.
     ECDSA_256k1N:  str = '1AAA'  # ECDSA secp256k1 verification key non-transferable, basic derivation.
     ECDSA_256k1:   str = '1AAB'  # ECDSA public verification or encryption key, basic derivation
+    Ed448N:        str = '1AAC'  # Ed448 verification key non-transferable, basic derivation.
+    Ed448:         str = '1AAD'  # Ed448 verification key, basic derivation.
+    Ed448_Sig:     str = '1AAE'  # Ed448 signature. Self-signing derivation.
     ECDSA_256r1N:  str = "1AAI"  # ECDSA secp256r1 verification key non-transferable, basic derivation.
     ECDSA_256r1:   str = "1AAJ"  # ECDSA secp256r1 verification or encryption key, basic derivation
 
@@ -596,6 +580,50 @@ def __iter__(self):
 PreDex = PreCodex()  # Make instance
 
 
+@dataclass(frozen=True)
+class NonTransCodex:
+    """
+    NonTransCodex is codex all non-transferable derivation codes
+    Only provide defined codes.
+    Undefined are left out so that inclusion(exclusion) via 'in' operator works.
+    """
+    Ed25519N: str = 'B'  # Ed25519 verification key non-transferable, basic derivation.
+    ECDSA_256k1N: str = '1AAA'  # ECDSA secp256k1 verification key non-transferable, basic derivation.
+    Ed448N: str = '1AAC'  # Ed448 verification key non-transferable, basic derivation.
+    ECDSA_256r1N: str = "1AAI"  # ECDSA secp256r1 verification key non-transferable, basic derivation.
+
+    def __iter__(self):
+        return iter(astuple(self))
+
+
+NonTransDex = NonTransCodex()  # Make instance
+
+
+@dataclass(frozen=True)
+class PreNonDigCodex:
+    """
+    PreNonDigCodex is codex all prefixive but non-digestive derivation codes
+    Only provide defined codes.
+    Undefined are left out so that inclusion(exclusion) via 'in' operator works.
+    """
+    Ed25519N:      str = 'B'  # Ed25519 verification key non-transferable, basic derivation.
+    Ed25519:       str = 'D'  # Ed25519 verification key, basic derivation.
+    ECDSA_256k1N:  str = '1AAA'  # ECDSA secp256k1 verification key non-transferable, basic derivation.
+    ECDSA_256k1:   str = '1AAB'  # ECDSA public verification or encryption key, basic derivation
+    Ed448N:        str = '1AAC'  # Ed448 verification key non-transferable, basic derivation.
+    Ed448:         str = '1AAD'  # Ed448 verification key, basic derivation.
+    ECDSA_256r1N:  str = "1AAI"  # ECDSA secp256r1 verification key non-transferable, basic derivation.
+    ECDSA_256r1:   str = "1AAJ"  # ECDSA secp256r1 verification or encryption key, basic derivation
+
+    def __iter__(self):
+        return iter(astuple(self))
+
+
+PreNonDigDex = PreNonDigCodex()  # Make instance
+
+
+
+
 # namedtuple for size entries in Matter  and Counter derivation code tables
 # hs is the hard size int number of chars in hard (stable) part of code
 # ss is the soft size int number of chars in soft (unstable) part of code
@@ -3298,91 +3326,6 @@ def __init__(self, raw=None, code=None, ked=None, allows=None, **kwa):
         #elif self.code in [MtrDex.Ed25519, MtrDex.ECDSA_256r1, MtrDex.ECDSA_256k1]:
             #self._verify = self._verify_transferable
 
-    def derive(self, ked):
-        """
-        Returns tuple (raw, code) of aid prefix as derived from key event dict ked.
-                uses a derivation code specific _derive method
-
-        Parameters:
-            ked is inception key event dict
-            seed is only used for sig derivation it is the secret key/secret
-
-        """
-        ilk = ked["t"]
-        if ilk not in (Ilks.icp, Ilks.dip, Ilks.vcp, Ilks.iss):
-            raise ValueError("Nonincepting ilk={} for prefix derivation.".format(ilk))
-
-        # Serder now does this check
-        #labels = getattr(Labels, ilk)
-        #for k in labels:
-            #if k not in ked:
-                #raise ValidationError("Missing element = {} from {} event for "
-                                      #"evt = {}.".format(k, ilk, ked))
-
-        return (self._derive(ked=ked))
-
-    def verify(self, ked, prefixed=False):
-        """
-        Returns True if derivation from ked for .code matches .qb64 and
-                If prefixed also verifies ked["i"] matches .qb64
-                False otherwise
-
-        Parameters:
-            ked is inception key event dict
-        """
-        ilk = ked["t"]
-        if ilk not in (Ilks.icp, Ilks.dip, Ilks.vcp, Ilks.iss):
-            raise ValueError("Nonincepting ilk={} for prefix derivation.".format(ilk))
-
-        # Serder now does this check
-        #labels = getattr(Labels, ilk)
-        #for k in labels:
-            #if k not in ked:
-                #raise ValidationError("Missing element = {} from {} event for "
-                                      #"evt = {}.".format(k, ilk, ked))
-
-        return (self._verify(ked=ked, pre=self.qb64, prefixed=prefixed))
-
-    def _derive_non_transferable(self, ked):
-        """
-        Returns tuple (raw, code) of basic nontransferable Ed25519 prefix (qb64)
-            as derived from inception key event dict ked keys[0]
-        """
-        ked = dict(ked)  # make copy so don't clobber original ked
-        try:
-            keys = ked["k"]
-            if len(keys) != 1:
-                raise DerivationError("Basic derivation needs at most 1 key "
-                                      " got {} keys instead".format(len(keys)))
-            verfer = Verfer(qb64=keys[0])
-        except Exception as ex:
-            raise DerivationError("Error extracting public key ="
-                                  " = {}".format(ex))
-
-        if verfer.code not in [MtrDex.Ed25519N, MtrDex.ECDSA_256r1N, MtrDex.ECDSA_256k1N]:
-            raise DerivationError("Mismatch derivation code = {}."
-                                  "".format(verfer.code))
-
-        try:
-            if verfer.code in [MtrDex.Ed25519N, MtrDex.ECDSA_256r1N, MtrDex.ECDSA_256k1N] and ked["n"]:
-                raise DerivationError("Non-empty nxt = {} for non-transferable"
-                                      " code = {}".format(ked["n"],
-                                                          verfer.code))
-
-            if verfer.code in [MtrDex.Ed25519N, MtrDex.ECDSA_256r1N, MtrDex.ECDSA_256k1N] and "b" in ked and ked["b"]:
-                raise DerivationError("Non-empty b = {} for non-transferable"
-                                      " code = {}".format(ked["b"],
-                                                          verfer.code))
-
-            if verfer.code in [MtrDex.Ed25519N, MtrDex.ECDSA_256r1N, MtrDex.ECDSA_256k1N] and "a" in ked and ked["a"]:
-                raise DerivationError("Non-empty a = {} for non-transferable"
-                                      " code = {}".format(ked["a"],
-                                                          verfer.code))
-
-        except Exception as ex:
-            raise DerivationError("Error checking nxt = {}".format(ex))
-
-        return (verfer.raw, verfer.code)
 
     def _verify_non_transferable(self, ked, pre, prefixed=False):
         """
@@ -3412,27 +3355,7 @@ def _verify_non_transferable(self, ked, pre, prefixed=False):
 
         return True
 
-    def _derive_transferable(self, ked):
-        """
-        Returns tuple (raw, code) of basic Ed25519 prefix (qb64)
-            as derived from inception key event dict ked keys[0]
-        """
-        ked = dict(ked)  # make copy so don't clobber original ked
-        try:
-            keys = ked["k"]
-            if len(keys) != 1:
-                raise DerivationError("Basic derivation needs at most 1 key "
-                                      " got {} keys instead".format(len(keys)))
-            verfer = Verfer(qb64=keys[0])
-        except Exception as ex:
-            raise DerivationError("Error extracting public key ="
-                                  " = {}".format(ex))
 
-        if verfer.code not in [MtrDex.Ed25519, MtrDex.ECDSA_256r1, MtrDex.ECDSA_256k1]:
-            raise DerivationError("Mismatch derivation code = {}"
-                                  "".format(verfer.code))
-
-        return (verfer.raw, verfer.code)
 
     def _verify_transferable(self, ked, pre, prefixed=False):
         """
@@ -3461,51 +3384,6 @@ def _verify_transferable(self, ked, pre, prefixed=False):
         return True
 
 
-    def _derive_blake3_256(self, ked):
-        """
-        Returns tuple (raw, code) of pre (qb64) as blake3 digest
-            as derived from inception key event dict ked
-        """
-        ked = dict(ked)  # make copy so don't clobber original ked
-        ilk = ked["t"]
-        if ilk not in (Ilks.icp, Ilks.dip, Ilks.vcp, Ilks.iss):
-            raise DerivationError("Invalid ilk = {} to derive pre.".format(ilk))
-
-        # put in dummy pre to get size correct
-        ked["i"] = self.Dummy * Matter.Sizes[MtrDex.Blake3_256].fs
-        ked["d"] = ked["i"]  # must be same dummy
-        #raw, proto, kind, ked, version = sizeify(ked=ked)
-        raw, _, _, _, _ = sizeify(ked=ked)
-        dig = blake3.blake3(raw).digest()  # digest with dummy 'i' and 'd'
-        return (dig, MtrDex.Blake3_256)  # dig is derived correct new 'i' and 'd'
-
-
-    def _verify_blake3_256(self, ked, pre, prefixed=False):
-        """
-        Returns True if verified False otherwise
-        Verify derivation of fully qualified Base64 prefix from
-        inception key event dict (ked)
-
-        Parameters:
-            ked is inception key event dict
-            pre is Base64 fully qualified default to .qb64
-        """
-        try:
-            raw, code = self._derive_blake3_256(ked=ked)  # replace with dummy 'i'
-            crymat = Matter(raw=raw, code=MtrDex.Blake3_256)
-            if crymat.qb64 != pre:  # derived raw with dummy 'i' must match pre
-                return False
-
-            if prefixed and ked["i"] != pre:  # incoming 'i' must match pre
-                return False
-
-            if ked["i"] != ked["d"]:  # when digestive then SAID must match pre
-                return False
-
-        except Exception as ex:
-            return False
-
-        return True
 
 
 

src/keri/core/eventing.py

@@ -761,7 +761,6 @@ def incept(keys,
         saids = {'i': code}
 
     serder = serdering.SerderKERI(sad=ked, makify=True, saids=saids)
-    serder._verify()  # raises error if fails verifications
     return serder
 
 
@@ -926,12 +925,8 @@ def rotate(pre,
                )
 
     serder = serdering.SerderKERI(sad=ked, makify=True)
-    serder._verify()  # raises error if fails verifications
     return serder
 
-    #_, ked = coring.Saider.saidify(sad=ked)
-
-    #return Serder(ked=ked)  # return serialized ked
 
 def deltate(pre,
            keys,
@@ -1007,13 +1002,8 @@ def interact(pre,
                )
 
     serder = serdering.SerderKERI(sad=sad, makify=True)
-    serder._verify()  # raises error if fails verifications
     return serder
 
-    #_, ked = coring.Saider.saidify(sad=ked)
-
-    #return Serder(ked=ked)  # return serialized ked
-
 
 def receipt(pre,
             sn,
@@ -1050,7 +1040,6 @@ def receipt(pre,
                )
 
     serder = serdering.SerderKERI(sad=sad, makify=True)
-    serder._verify()  # raises error if fails verifications
     return serder
 
 
@@ -1105,7 +1094,6 @@ def query(route="",
                )
 
     serder = serdering.SerderKERI(sad=sad, makify=True)
-    serder._verify()  # raises error if fails verifications
     return serder
 
     #_, ked = coring.Saider.saidify(sad=ked)
@@ -1162,7 +1150,6 @@ def reply(route="",
                )
 
     serder = serdering.SerderKERI(sad=sad, makify=True)
-    serder._verify()  # raises error if fails verifications
     return serder
 
 
@@ -1204,7 +1191,6 @@ def prod(route="",
                )
 
     serder = serdering.SerderKERI(sad=sad, makify=True)
-    serder._verify()  # raises error if fails verifications
     return serder
 
     #_, ked = coring.Saider.saidify(sad=ked)
@@ -1264,7 +1250,6 @@ def bare(route="",
                )
 
     serder = serdering.SerderKERI(sad=sad, makify=True)
-    serder._verify()  # raises error if fails verifications
     return serder
 
     #_, sad = coring.Saider.saidify(sad=sad)