initial set of edge cases (#110)

* initial set of edge cases

* commenting out test checking for nil

* fixing for ci lint

* ci fix

* removing unwanted assert

* more fixes to tests

* removing commented code

* separating tests for integration only

* changing test name and adding OP issue link

* Update e2e/server_test.go

Co-authored-by: Samuel Laferriere <[email protected]>

* changed test name and fn name

* test config changes

* making the linter happy

* adding comments

---------

Co-authored-by: anupsv <[email protected]>
Co-authored-by: Samuel Laferriere <[email protected]>

e2e/server_test.go

@@ -6,16 +6,69 @@ import (
 	"time"
 
 	"github.com/Layr-Labs/eigenda-proxy/client"
+
 	"github.com/Layr-Labs/eigenda-proxy/e2e"
 	"github.com/Layr-Labs/eigenda-proxy/store"
 	op_plasma "github.com/ethereum-optimism/optimism/op-plasma"
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
 func useMemory() bool {
 	return !runTestnetIntegrationTests
 }
 
+func isNilPtrDerefPanic(err string) bool {
+	return strings.Contains(err, "panic") && strings.Contains(err, "SIGSEGV") &&
+		strings.Contains(err, "nil pointer dereference")
+}
+
+// TestOpClientKeccak256MalformedInputs tests the NewDAClient from op_plasma by setting and getting against []byte("")
+// preimage. It sets the precompute option to false on the NewDAClient.
+func TestOpClientKeccak256MalformedInputs(t *testing.T) {
+	if !runIntegrationTests || runTestnetIntegrationTests {
+		t.Skip("Skipping test as TESTNET env set or INTEGRATION var not set")
+	}
+
+	t.Parallel()
+	testCfg := e2e.TestConfig(useMemory())
+	testCfg.UseKeccak256ModeS3 = true
+	tsConfig := e2e.TestSuiteConfig(t, testCfg)
+	ts, kill := e2e.CreateTestSuite(t, tsConfig)
+	defer kill()
+
+	// nil commitment. Should return an error but currently is not. This needs to be fixed by OP
+	// Ref: https://github.com/ethereum-optimism/optimism/issues/11987
+	// daClient := op_plasma.NewDAClient(ts.Address(), false, true)
+	// t.Run("nil commitment case", func(t *testing.T) {
+	//	var commit op_plasma.CommitmentData
+	//	_, err := daClient.GetInput(ts.Ctx, commit)
+	//	require.Error(t, err)
+	//	assert.True(t, !isPanic(err.Error()))
+	// })
+
+	daClientPcFalse := op_plasma.NewDAClient(ts.Address(), false, false)
+
+	t.Run("input bad data to SetInput & GetInput", func(t *testing.T) {
+		testPreimage := []byte("") // Empty preimage
+		_, err := daClientPcFalse.SetInput(ts.Ctx, testPreimage)
+		require.Error(t, err)
+
+		// should fail with proper error message as is now, and cannot contain panics or nils
+		assert.True(t, strings.Contains(err.Error(), "invalid input") && !isNilPtrDerefPanic(err.Error()))
+
+		// The below test panics silently.
+		input := op_plasma.NewGenericCommitment([]byte(""))
+		_, err = daClientPcFalse.GetInput(ts.Ctx, input)
+		require.Error(t, err)
+
+		// Should not fail on slice bounds out of range. This needs to be fixed by OP.
+		// Refer to issue: https://github.com/ethereum-optimism/optimism/issues/11987
+		// assert.False(t, strings.Contains(err.Error(), ": EOF") && !isPanic(err.Error()))
+	})
+
+}
+
 func TestOptimismClientWithKeccak256Commitment(t *testing.T) {
 	if !runIntegrationTests && !runTestnetIntegrationTests {
 		t.Skip("Skipping test as INTEGRATION or TESTNET env var not set")
@@ -32,14 +85,16 @@ func TestOptimismClientWithKeccak256Commitment(t *testing.T) {
 
 	daClient := op_plasma.NewDAClient(ts.Address(), false, true)
 
-	testPreimage := []byte(e2e.RandString(100))
+	t.Run("normal case", func(t *testing.T) {
+		testPreimage := []byte(e2e.RandString(100))
 
-	commit, err := daClient.SetInput(ts.Ctx, testPreimage)
-	require.NoError(t, err)
+		commit, err := daClient.SetInput(ts.Ctx, testPreimage)
+		require.NoError(t, err)
 
-	preimage, err := daClient.GetInput(ts.Ctx, commit)
-	require.NoError(t, err)
-	require.Equal(t, testPreimage, preimage)
+		preimage, err := daClient.GetInput(ts.Ctx, commit)
+		require.NoError(t, err)
+		require.Equal(t, testPreimage, preimage)
+	})
 }
 
 func TestKeccak256CommitmentRequestErrorsWhenS3NotSet(t *testing.T) {
@@ -96,6 +151,75 @@ func TestOptimismClientWithGenericCommitment(t *testing.T) {
 	require.Equal(t, testPreimage, preimage)
 }
 
+// TestProxyClientServerIntegration tests the proxy client and server integration by setting the data as a single byte,
+// many unicode characters, single unicode character and an empty preimage. It then tries to get the data from the
+// proxy server with empty byte, single byte and random string.
+func TestProxyClientServerIntegration(t *testing.T) {
+	if !runIntegrationTests && !runTestnetIntegrationTests {
+		t.Skip("Skipping test as INTEGRATION or TESTNET env var not set")
+	}
+
+	t.Parallel()
+
+	tsConfig := e2e.TestSuiteConfig(t, e2e.TestConfig(useMemory()))
+	ts, kill := e2e.CreateTestSuite(t, tsConfig)
+	defer kill()
+
+	cfg := &client.Config{
+		URL: ts.Address(),
+	}
+	daClient := client.New(cfg)
+
+	t.Run("single byte preimage set data case", func(t *testing.T) {
+		testPreimage := []byte{1} // single byte preimage
+		t.Log("Setting input data on proxy server...")
+		_, err := daClient.SetData(ts.Ctx, testPreimage)
+		require.NoError(t, err)
+	})
+
+	t.Run("unicode preimage set data case", func(t *testing.T) {
+		testPreimage := []byte("§§©ˆªªˆ˙√ç®∂§∞¶§ƒ¥√¨¥√¨¥ƒƒ©˙˜ø˜˜˜∫˙∫¥∫√†®®√稈¨˙ï") // many unicode characters
+		t.Log("Setting input data on proxy server...")
+		_, err := daClient.SetData(ts.Ctx, testPreimage)
+		require.NoError(t, err)
+
+		testPreimage = []byte("§") // single unicode character
+		t.Log("Setting input data on proxy server...")
+		_, err = daClient.SetData(ts.Ctx, testPreimage)
+		require.NoError(t, err)
+
+	})
+
+	t.Run("empty preimage set data case", func(t *testing.T) {
+		testPreimage := []byte("") // Empty preimage
+		t.Log("Setting input data on proxy server...")
+		_, err := daClient.SetData(ts.Ctx, testPreimage)
+		require.NoError(t, err)
+	})
+
+	t.Run("get data edge cases", func(t *testing.T) {
+		testCert := []byte("")
+		_, err := daClient.GetData(ts.Ctx, testCert)
+		require.Error(t, err)
+		assert.True(t, strings.Contains(err.Error(),
+			"commitment is too short") && !isNilPtrDerefPanic(err.Error()))
+
+		testCert = []byte{1}
+		_, err = daClient.GetData(ts.Ctx, testCert)
+		require.Error(t, err)
+		assert.True(t, strings.Contains(err.Error(),
+			"commitment is too short") && !isNilPtrDerefPanic(err.Error()))
+
+		testCert = []byte(e2e.RandString(10000))
+		_, err = daClient.GetData(ts.Ctx, testCert)
+		require.Error(t, err)
+		assert.True(t, strings.Contains(err.Error(),
+			"failed to decode DA cert to RLP format: rlp: expected input list for verify.Certificate") &&
+			!isNilPtrDerefPanic(err.Error()))
+	})
+
+}
+
 func TestProxyClient(t *testing.T) {
 	if !runIntegrationTests && !runTestnetIntegrationTests {
 		t.Skip("Skipping test as INTEGRATION or TESTNET env var not set")