Master (#1262)

* clear

* feat: Add everything

* fix: Commenht

crypto/mpc/codec_test.go

@@ -0,0 +1,178 @@
+package mpc
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestKeyShareGeneration(t *testing.T) {
+	t.Run("Generate Valid Enclave", func(t *testing.T) {
+		// Generate enclave
+		enclave, err := NewEnclave()
+		require.NoError(t, err)
+		require.NotNil(t, enclave)
+
+		// Validate enclave contents
+		assert.True(t, enclave.IsValid())
+	})
+
+	t.Run("Export and Import", func(t *testing.T) {
+		// Generate original enclave
+		original, err := NewEnclave()
+		require.NoError(t, err)
+
+		// Test key for encryption/decryption (32 bytes)
+		testKey := []byte("test-key-12345678-test-key-123456")
+
+		// Test Export/Import
+		t.Run("Full Enclave", func(t *testing.T) {
+			// Export enclave
+			data, err := original.Encrypt(testKey)
+			require.NoError(t, err)
+			require.NotEmpty(t, data)
+
+			// Create new empty enclave
+			newEnclave, err := NewEnclave()
+			require.NoError(t, err)
+
+			// Verify the imported enclave works by signing
+			testData := []byte("test message")
+			sig, err := newEnclave.Sign(testData)
+			require.NoError(t, err)
+			valid, err := newEnclave.Verify(testData, sig)
+			require.NoError(t, err)
+			assert.True(t, valid)
+		})
+	})
+
+	t.Run("Encrypt and Decrypt", func(t *testing.T) {
+		// Generate original enclave
+		original, err := NewEnclave()
+		require.NoError(t, err)
+		require.NotNil(t, original)
+
+		// Test key for encryption/decryption (32 bytes)
+		testKey := []byte("test-key-12345678-test-key-123456")
+
+		// Test Encrypt
+		encrypted, err := original.Encrypt(testKey)
+		require.NoError(t, err)
+		require.NotEmpty(t, encrypted)
+
+		// Test Decrypt
+		decrypted, err := original.Decrypt(testKey, encrypted)
+		require.NoError(t, err)
+		require.NotEmpty(t, decrypted)
+
+		// Verify decrypted data matches original
+		originalData, err := original.Marshal()
+		require.NoError(t, err)
+		assert.Equal(t, originalData, decrypted)
+
+		// Test with wrong key should fail
+		wrongKey := []byte("wrong-key-12345678-wrong-key-123456")
+		_, err = original.Decrypt(wrongKey, encrypted)
+		assert.Error(t, err, "Decryption with wrong key should fail")
+	})
+}
+
+func TestEnclaveOperations(t *testing.T) {
+	t.Run("Signing and Verification", func(t *testing.T) {
+		// Generate valid enclave
+		enclave, err := NewEnclave()
+		require.NoError(t, err)
+
+		// Test signing
+		testData := []byte("test message")
+		signature, err := enclave.Sign(testData)
+		require.NoError(t, err)
+		require.NotNil(t, signature)
+
+		// Verify the signature
+		valid, err := enclave.Verify(testData, signature)
+		require.NoError(t, err)
+		assert.True(t, valid)
+
+		// Test invalid data verification
+		invalidData := []byte("wrong message")
+		valid, err = enclave.Verify(invalidData, signature)
+		require.NoError(t, err)
+		assert.False(t, valid)
+	})
+
+	t.Run("Refresh Operation", func(t *testing.T) {
+		enclave, err := NewEnclave()
+		require.NoError(t, err)
+
+		// Test refresh
+		refreshedEnclave, err := enclave.Refresh()
+		require.NoError(t, err)
+		require.NotNil(t, refreshedEnclave)
+
+		// Verify refreshed enclave is valid
+		assert.True(t, refreshedEnclave.IsValid())
+	})
+}
+
+func TestEnclaveDataAccess(t *testing.T) {
+	t.Run("GetData", func(t *testing.T) {
+		// Generate enclave
+		enclave, err := NewEnclave()
+		require.NoError(t, err)
+		require.NotNil(t, enclave)
+
+		// Get the enclave data
+		data := enclave.GetData()
+		require.NotNil(t, data, "GetData should return non-nil value")
+
+		// Verify the data is valid
+		assert.True(t, data.IsValid(), "Enclave data should be valid")
+
+		// Verify the public key in the data matches the enclave's public key
+		assert.Equal(t, enclave.PubKeyHex(), data.PubKeyHex(), "Public keys should match")
+	})
+
+	t.Run("PubKeyHex", func(t *testing.T) {
+		// Generate enclave
+		enclave, err := NewEnclave()
+		require.NoError(t, err)
+		require.NotNil(t, enclave)
+
+		// Get the public key hex
+		pubKeyHex := enclave.PubKeyHex()
+		require.NotEmpty(t, pubKeyHex, "PubKeyHex should return non-empty string")
+
+		// Check that it's a valid hex string (should be 66 chars for compressed point: 0x02/0x03 + 32 bytes)
+		assert.GreaterOrEqual(
+			t,
+			len(pubKeyHex),
+			66,
+			"Public key hex should be at least 66 characters",
+		)
+		assert.True(t, len(pubKeyHex)%2 == 0, "Hex string should have even length")
+
+		// Compare with the enclave data's public key
+		data := enclave.GetData()
+		assert.Equal(
+			t,
+			data.PubKeyHex(),
+			pubKeyHex,
+			"Public key hex should match the one from GetData",
+		)
+
+		// Verify that two different enclaves have different public keys
+		enclave2, err := NewEnclave()
+		require.NoError(t, err)
+		require.NotNil(t, enclave2)
+
+		pubKeyHex2 := enclave2.PubKeyHex()
+		assert.NotEqual(
+			t,
+			pubKeyHex,
+			pubKeyHex2,
+			"Different enclaves should have different public keys",
+		)
+	})
+}