refactor

Author: blindchaser

sc/universal_accumulator/core.go renamed to sc/universal_accumulator/cgo_bridge.go

@@ -37,7 +37,7 @@ func addHashedElementsWrapper(accumulator unsafe.Pointer, flatHashes []byte, cou
 	// Use C.add_hashed_elements directly
 	ret := C.add_hashed_elements((*C.t_state)(accumulator), (*C.uchar)(unsafe.Pointer(&flatHashes[0])), C.int(count))
 	if ret != 0 {
-		return errors.New("C.add_hashed_elements failed, possibly due to memory allocation error")
+		return errors.New("add_hashed_elements failed, possibly due to memory allocation error")
 	}
 
 	return nil
@@ -51,7 +51,7 @@ func batchDelHashedElementsWrapper(accumulator unsafe.Pointer, flatHashes []byte
 	// Use the existing batch_del_hashed_elements C function
 	ret := C.batch_del_hashed_elements((*C.t_state)(accumulator), (*C.uchar)(unsafe.Pointer(&flatHashes[0])), C.int(count))
 	if ret != 0 {
-		return errors.New("C.batch_del_hashed_elements failed, possibly due to memory allocation error")
+		return errors.New("batch_del_hashed_elements failed, possibly due to memory allocation error")
 	}
 
 	return nil

sc/universal_accumulator/core_test.go renamed to sc/universal_accumulator/cgo_bridge_test.go

@@ -8,7 +8,6 @@ import (
 )
 
 // UniversalAccumulator provides the main interface for the Universal Accumulator.
-// This follows the same patterns as other storage APIs in the repo.
 type UniversalAccumulator struct {
 	engine *AccumulatorEngine
 	mu     sync.RWMutex

sc/universal_accumulator/api.go renamed to sc/universal_accumulator/client.go

@@ -0,0 +1,93 @@
+package universalaccumulator
+
+import "errors"
+
+// Core accumulator errors
+var (
+	// ErrNotInitialized indicates the accumulator is not properly initialized
+	ErrNotInitialized = errors.New("accumulator not initialized")
+
+	// ErrInvalidFactor indicates an invalid factor was provided
+	ErrInvalidFactor = errors.New("invalid factor")
+
+	// ErrFactorSize indicates the factor size is incorrect
+	ErrFactorSize = errors.New("empty factor")
+
+	// ErrAlreadyInitialized indicates the accumulator is already initialized
+	ErrAlreadyInitialized = errors.New("accumulator already initialized")
+)
+
+// Witness and proof errors
+var (
+	// ErrWitnessGeneration indicates failure to generate a witness
+	ErrWitnessGeneration = errors.New("failed to generate witness")
+
+	// ErrWitnessVerification indicates failure to verify a witness
+	ErrWitnessVerification = errors.New("failed to verify witness")
+
+	// ErrInvalidWitness indicates the witness is invalid or corrupted
+	ErrInvalidWitness = errors.New("invalid witness")
+
+	// ErrElementHashSize indicates incorrect element hash size
+	ErrElementHashSize = errors.New("element hash must be 32 bytes")
+)
+
+// State management errors
+var (
+	// ErrStateCalculation indicates failure to calculate state
+	ErrStateCalculation = errors.New("failed to calculate state")
+
+	// ErrStateRestore indicates failure to restore state from factor
+	ErrStateRestore = errors.New("failed to restore state from factor")
+
+	// ErrSnapshotCreation indicates failure to create snapshot
+	ErrSnapshotCreation = errors.New("failed to create snapshot")
+
+	// ErrSnapshotRestore indicates failure to restore from snapshot
+	ErrSnapshotRestore = errors.New("failed to restore from snapshot")
+)
+
+// Storage and persistence errors
+var (
+	// ErrFactorNotFound indicates the factor for given height was not found
+	ErrFactorNotFound = errors.New("factor not found")
+
+	// ErrRootNotFound indicates the root for given height was not found
+	ErrRootNotFound = errors.New("root not found")
+
+	// ErrStorageValueNotFound indicates the storage value was not found
+	ErrStorageValueNotFound = errors.New("storage value not found")
+
+	// ErrInvalidHeight indicates an invalid block height
+	ErrInvalidHeight = errors.New("invalid block height")
+)
+
+// Proof API errors
+var (
+	// ErrInvalidAddress indicates an invalid address format
+	ErrInvalidAddress = errors.New("invalid address")
+
+	// ErrInvalidStorageKey indicates an invalid storage key format
+	ErrInvalidStorageKey = errors.New("invalid storage key")
+
+	// ErrProofGeneration indicates failure to generate proof
+	ErrProofGeneration = errors.New("failed to generate proof")
+
+	// ErrProofVerification indicates failure to verify proof
+	ErrProofVerification = errors.New("failed to verify proof")
+
+	// ErrRootMismatch indicates proof root doesn't match consensus root
+	ErrRootMismatch = errors.New("proof root doesn't match consensus root")
+)
+
+// CGO and C library errors
+var (
+	// ErrCGOCall indicates a CGO function call failed
+	ErrCGOCall = errors.New("CGO function call failed")
+
+	// ErrRelicInit indicates RELIC library initialization failed
+	ErrRelicInit = errors.New("RELIC library initialization failed")
+
+	// ErrMemoryAllocation indicates memory allocation failed
+	ErrMemoryAllocation = errors.New("memory allocation failed")
+)

sc/universal_accumulator/api_test.go renamed to sc/universal_accumulator/client_test.go

@@ -624,103 +624,6 @@ func TestWitnessValidationAcrossUpdates(t *testing.T) {
 	t.Logf("Witness validation across updates successful")
 }
 
-// Benchmark tests for performance measurement
-
-// BenchmarkAddEntries_1K benchmarks 1K entry addition.
-func BenchmarkAddEntries_1K(b *testing.B) {
-	benchmarkAddEntries(b, 1000)
-}
-
-// BenchmarkAddEntries_10K benchmarks 10K entry addition.
-func BenchmarkAddEntries_10K(b *testing.B) {
-	benchmarkAddEntries(b, 10000)
-}
-
-// BenchmarkAddEntries_100K benchmarks 100K entry addition.
-func BenchmarkAddEntries_100K(b *testing.B) {
-	benchmarkAddEntries(b, 100000)
-}
-
-// benchmarkAddEntries runs addition benchmark.
-func benchmarkAddEntries(b *testing.B, numEntries int) {
-	acc, err := NewUniversalAccumulator(10)
-	if err != nil {
-		b.Fatalf("Failed to create accumulator: %v", err)
-	}
-	defer acc.Close()
-
-	entries := generateTestEntries(numEntries)
-
-	b.ResetTimer()
-	for i := range b.N {
-		_ = i // unused loop variable
-		// Reset accumulator state for each iteration
-		err = acc.Reset()
-		if err != nil {
-			b.Fatalf("Failed to reset accumulator: %v", err)
-		}
-
-		err = acc.AddEntries(entries)
-		if err != nil {
-			b.Fatalf("Failed to add entries: %v", err)
-		}
-	}
-}
-
-// BenchmarkRootCalculation benchmarks root computation.
-func BenchmarkRootCalculation(b *testing.B) {
-	acc, err := NewUniversalAccumulator(10)
-	if err != nil {
-		b.Fatalf("Failed to create accumulator: %v", err)
-	}
-	defer acc.Close()
-
-	// Add test data
-	entries := generateTestEntries(10000)
-	err = acc.AddEntries(entries)
-	if err != nil {
-		b.Fatalf("Failed to add entries: %v", err)
-	}
-
-	b.ResetTimer()
-	for i := range b.N {
-		_ = i // unused loop variable
-		_, err = acc.CalculateRoot()
-		if err != nil {
-			b.Fatalf("Failed to calculate root: %v", err)
-		}
-	}
-}
-
-// BenchmarkWitnessOperations benchmarks witness issuance and verification.
-func BenchmarkWitnessOperations(b *testing.B) {
-	acc, err := NewUniversalAccumulator(10)
-	if err != nil {
-		b.Fatalf("Failed to create accumulator: %v", err)
-	}
-	defer acc.Close()
-
-	// Add test data
-	entries := generateTestEntries(1000)
-	err = acc.AddEntries(entries)
-	if err != nil {
-		b.Fatalf("Failed to add entries: %v", err)
-	}
-
-	testKey := "key_500"
-	testValue := "value_500" // Corresponding value
-
-	b.ResetTimer()
-	for i := range b.N {
-		_ = i // unused loop variable
-		witness, err := acc.IssueWitness([]byte(testKey), []byte(testValue), true)
-		if err != nil {
-			b.Fatalf("Failed to issue witness: %v", err)
-		}
-		witness.Free()
-	}
-}
-
 // TestAccumulatorEngineErrorPaths tests error paths in AccumulatorEngine.
 func TestAccumulatorEngineErrorPaths(t *testing.T) {
 	// Test uninitialized engine