Op code cleanup

Author: ethanfrey

go/ops.go

@@ -1,6 +1,7 @@
 package proofs
 
 import (
+	"bytes"
 	"crypto"
 	// adds sha256 capability to crypto.SHA256
 	_ "crypto/sha256"
@@ -32,6 +33,28 @@ func (op *LeafOp) Apply(key []byte, value []byte) ([]byte, error) {
 	return doHash(op.Hash, data)
 }
 
+func (op *LeafOp)CheckAgainstSpec(spec *ProofSpec) error {
+	lspec := spec.LeafSpec
+
+	if op.Hash != lspec.Hash {
+		return fmt.Errorf("Unexpected HashOp: %d", op.Hash)
+	}
+	if op.PrehashKey != lspec.PrehashKey {
+		return fmt.Errorf("Unexpected PrehashKey: %d", op.PrehashKey)
+	}
+	if op.PrehashValue != lspec.PrehashValue {
+		return fmt.Errorf("Unexpected PrehashValue: %d", op.PrehashValue)
+	}
+	if op.Length != lspec.Length {
+		return fmt.Errorf("Unexpected LengthOp: %d", op.Length)
+	}
+	if !bytes.HasPrefix(op.Prefix, lspec.Prefix) {
+		return fmt.Errorf("Leaf Prefix doesn't start with %X", lspec.Prefix)
+	}
+	return nil
+}
+
+
 func (op *InnerOp) Apply(child []byte) ([]byte, error) {
 	if len(child) == 0 {
 		return nil, fmt.Errorf("Inner op needs child value")
@@ -41,6 +64,15 @@ func (op *InnerOp) Apply(child []byte) ([]byte, error) {
 	return doHash(op.Hash, preimage)
 }
 
+func (inner *InnerOp)CheckAgainstSpec(spec *ProofSpec) error {
+	leafPrefix := spec.LeafSpec.Prefix
+	if bytes.HasPrefix(inner.Prefix, leafPrefix) {
+		return fmt.Errorf("Inner Prefix starts with %X", leafPrefix)
+	}
+	return nil
+}
+
+
 func prepareLeafData(hashOp HashOp, lengthOp LengthOp, data []byte) ([]byte, error) {
 	// TODO: lengthop before or after hash ???
 	hdata, err := doHashOrNoop(hashOp, data)

go/proof.go

@@ -82,44 +82,18 @@ func (p *ExistenceProof) CheckAgainstSpec(spec *ProofSpec) error {
 	if p.GetLeaf() == nil {
 		return fmt.Errorf("Existence Proof needs defined LeafOp")
 	}
-	err := checkLeaf(p.Leaf, spec.LeafSpec)
+	err := p.Leaf.CheckAgainstSpec(spec)
 	if err != nil {
 		return err
 	}
 	for _, inner := range p.Path {
-		if err := checkInner(inner, spec.LeafSpec.Prefix); err != nil {
+		if err := inner.CheckAgainstSpec(spec); err != nil {
 			return err
 		}
 	}
 	return nil
 }
 
-func checkLeaf(leaf *LeafOp, spec *LeafOp) error {
-	if leaf.Hash != spec.Hash {
-		return fmt.Errorf("Unexpected HashOp: %d", leaf.Hash)
-	}
-	if leaf.PrehashKey != spec.PrehashKey {
-		return fmt.Errorf("Unexpected PrehashKey: %d", leaf.PrehashKey)
-	}
-	if leaf.PrehashValue != spec.PrehashValue {
-		return fmt.Errorf("Unexpected PrehashValue: %d", leaf.PrehashValue)
-	}
-	if leaf.Length != spec.Length {
-		return fmt.Errorf("Unexpected LengthOp: %d", leaf.Length)
-	}
-	if !bytes.HasPrefix(leaf.Prefix, spec.Prefix) {
-		return fmt.Errorf("Leaf Prefix doesn't start with %X", spec.Prefix)
-	}
-	return nil
-}
-
-func checkInner(inner *InnerOp, leafPrefix []byte) error {
-	if bytes.HasPrefix(inner.Prefix, leafPrefix) {
-		return fmt.Errorf("Inner Prefix starts with %X", leafPrefix)
-	}
-	return nil
-}
-
 // Verify does all checks to ensure this proof proves this key, value -> root
 // and matches the spec.
 func (p *NonExistenceProof) Verify(spec *ProofSpec, root CommitmentRoot, key []byte) error {

go/proof_test.go

@@ -225,7 +225,7 @@ func TestCheckLeaf(t *testing.T) {
 
 	for name, tc := range cases {
 		t.Run(name, func(t *testing.T) {
-			err := checkLeaf(tc.leaf, tc.spec)
+			err := tc.leaf.CheckAgainstSpec(&ProofSpec{LeafSpec: tc.spec})
 			if tc.isErr && err == nil {
 				t.Fatal("Expected error, but got nil")
 			} else if !tc.isErr && err != nil {