From 2c1636a339a9166d50ebda126e043c61808c834f Mon Sep 17 00:00:00 2001
From: anupsv <asv@asvs-wk.local>
Date: Sun, 1 Sep 2024 22:27:37 -0700
Subject: [PATCH 01/14] initial set of edge cases

---
 e2e/server_test.go | 135 +++++++++++++++++++++++++++++++++++++--------
 1 file changed, 112 insertions(+), 23 deletions(-)

diff --git a/e2e/server_test.go b/e2e/server_test.go
index 5c213ce0..5abec06a 100644
--- a/e2e/server_test.go
+++ b/e2e/server_test.go
@@ -1,20 +1,25 @@
 package e2e_test
 
 import (
-	"strings"
-	"testing"
-	"time"
-
 	"github.com/Layr-Labs/eigenda-proxy/client"
 	"github.com/Layr-Labs/eigenda-proxy/e2e"
 	op_plasma "github.com/ethereum-optimism/optimism/op-plasma"
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"strings"
+	"testing"
+	"time"
 )
 
 func useMemory() bool {
 	return !runTestnetIntegrationTests
 }
 
+func isPanic(err string) bool {
+	return strings.Contains(err, "panic") && strings.Contains(err, "SIGSEGV") &&
+		strings.Contains(err, "nil pointer dereference")
+}
+
 func TestOptimismClientWithKeccak256Commitment(t *testing.T) {
 	if !runIntegrationTests && !runTestnetIntegrationTests {
 		t.Skip("Skipping test as INTEGRATION or TESTNET env var not set")
@@ -29,15 +34,44 @@ func TestOptimismClientWithKeccak256Commitment(t *testing.T) {
 	defer kill()
 
 	daClient := op_plasma.NewDAClient(ts.Address(), false, true)
-
-	testPreimage := []byte(e2e.RandString(100))
-
-	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)
+	daClientPcFalse := op_plasma.NewDAClient(ts.Address(), false, false)
+
+	// nil commitment. Should return an error but currently is not
+	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()))
+	})
+
+	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") && !isPanic(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 EOF. Should fail before and return with proper error message
+		assert.False(t, strings.Contains(err.Error(), ": EOF") && !isPanic(err.Error()))
+	})
+
+	// nil commitment. Should return an error but currently not
+	t.Run("normal case", func(t *testing.T) {
+		testPreimage := []byte(e2e.RandString(100))
+
+		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)
+	})
 }
 
 /*
@@ -84,16 +118,71 @@ func TestProxyClient(t *testing.T) {
 	}
 	daClient := client.New(cfg)
 
-	testPreimage := []byte(e2e.RandString(100))
-
-	t.Log("Setting input data on proxy server...")
-	blobInfo, err := daClient.SetData(ts.Ctx, testPreimage)
-	require.NoError(t, err)
-
-	t.Log("Getting input data from proxy server...")
-	preimage, err := daClient.GetData(ts.Ctx, blobInfo)
-	require.NoError(t, err)
-	require.Equal(t, testPreimage, preimage)
+	t.Run("normal case case", func(t *testing.T) {
+		testPreimage := []byte(e2e.RandString(100))
+
+		t.Log("Setting input data on proxy server...")
+		blobInfo, err := daClient.SetData(ts.Ctx, testPreimage)
+		require.NoError(t, err)
+
+		t.Log("Getting input data from proxy server...")
+		preimage, err := daClient.GetData(ts.Ctx, blobInfo)
+		require.NoError(t, err)
+		require.Equal(t, testPreimage, preimage)
+	})
+
+	t.Run("single byte preimage set data case", func(t *testing.T) {
+		testPreimage := []byte{1} // Empty preimage
+		t.Log("Setting input data on proxy server...")
+		_, err := daClient.SetData(ts.Ctx, testPreimage)
+		require.NoError(t, err)
+		assert.True(t, !isPanic(err.Error()))
+	})
+
+	t.Run("unicode 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)
+		assert.True(t, !isPanic(err.Error()))
+
+		testPreimage = []byte("§") // Empty preimage
+		t.Log("Setting input data on proxy server...")
+		_, err = daClient.SetData(ts.Ctx, testPreimage)
+		require.NoError(t, err)
+		assert.True(t, !isPanic(err.Error()))
+
+	})
+
+	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)
+		assert.True(t, !isPanic(err.Error()))
+	})
+
+	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(),
+			"received error response, code=400, msg = commitment is empty") && !isPanic(err.Error()))
+
+		testCert = []byte{1}
+		_, err = daClient.GetData(ts.Ctx, testCert)
+		require.Error(t, err)
+		assert.True(t, strings.Contains(err.Error(),
+			"received error response, code=500, msg = failed to decode DA cert to RLP format: EOF") &&
+			!isPanic(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") &&
+			!isPanic(err.Error()))
+	})
 }
 
 func TestProxyServerWithLargeBlob(t *testing.T) {

From ddc223fc3ee0d76896487565a8155c2067df43c9 Mon Sep 17 00:00:00 2001
From: anupsv <asv@asvs-wk.local>
Date: Mon, 16 Sep 2024 15:54:04 -0700
Subject: [PATCH 02/14] commenting out test checking for nil

---
 e2e/server_test.go | 25 +++++++++++++------------
 1 file changed, 13 insertions(+), 12 deletions(-)

diff --git a/e2e/server_test.go b/e2e/server_test.go
index 5abec06a..b45dd3da 100644
--- a/e2e/server_test.go
+++ b/e2e/server_test.go
@@ -2,13 +2,14 @@ package e2e_test
 
 import (
 	"github.com/Layr-Labs/eigenda-proxy/client"
+	"strings"
+	"testing"
+	"time"
+
 	"github.com/Layr-Labs/eigenda-proxy/e2e"
 	op_plasma "github.com/ethereum-optimism/optimism/op-plasma"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-	"strings"
-	"testing"
-	"time"
 )
 
 func useMemory() bool {
@@ -36,13 +37,13 @@ func TestOptimismClientWithKeccak256Commitment(t *testing.T) {
 	daClient := op_plasma.NewDAClient(ts.Address(), false, true)
 	daClientPcFalse := op_plasma.NewDAClient(ts.Address(), false, false)
 
-	// nil commitment. Should return an error but currently is not
-	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()))
-	})
+	// nil commitment. Should return an error but currently is not. This needs to be fixed by OP
+	//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()))
+	//})
 
 	t.Run("input bad data to SetInput & GetInput", func(t *testing.T) {
 		testPreimage := []byte("") // Empty preimage
@@ -57,8 +58,8 @@ func TestOptimismClientWithKeccak256Commitment(t *testing.T) {
 		_, err = daClientPcFalse.GetInput(ts.Ctx, input)
 		require.Error(t, err)
 
-		// Should not fail on EOF. Should fail before and return with proper error message
-		assert.False(t, strings.Contains(err.Error(), ": EOF") && !isPanic(err.Error()))
+		// Should not fail on slice bounds out of range. This needs to be fixed by OP.
+		//assert.False(t, strings.Contains(err.Error(), ": EOF") && !isPanic(err.Error()))
 	})
 
 	// nil commitment. Should return an error but currently not

From a8c83b378026e4d2ac954f79fa1dc74ad69c7c87 Mon Sep 17 00:00:00 2001
From: anupsv <asv@asvs-wk.local>
Date: Mon, 16 Sep 2024 16:03:52 -0700
Subject: [PATCH 03/14] fixing for ci lint

---
 e2e/server_test.go | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/e2e/server_test.go b/e2e/server_test.go
index 788970fe..7c9f3233 100644
--- a/e2e/server_test.go
+++ b/e2e/server_test.go
@@ -39,12 +39,12 @@ func TestOptimismClientWithKeccak256Commitment(t *testing.T) {
 	daClientPcFalse := op_plasma.NewDAClient(ts.Address(), false, false)
 
 	// nil commitment. Should return an error but currently is not. This needs to be fixed by OP
-	//t.Run("nil commitment case", func(t *testing.T) {
+	// 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()))
-	//})
+	// })
 
 	t.Run("input bad data to SetInput & GetInput", func(t *testing.T) {
 		testPreimage := []byte("") // Empty preimage
@@ -60,7 +60,7 @@ func TestOptimismClientWithKeccak256Commitment(t *testing.T) {
 		require.Error(t, err)
 
 		// Should not fail on slice bounds out of range. This needs to be fixed by OP.
-		//assert.False(t, strings.Contains(err.Error(), ": EOF") && !isPanic(err.Error()))
+		// assert.False(t, strings.Contains(err.Error(), ": EOF") && !isPanic(err.Error()))
 	})
 
 	// nil commitment. Should return an error but currently not

From 040620f730f366c6d1e8ad6143b7dc519a3d4fb1 Mon Sep 17 00:00:00 2001
From: anupsv <asv@asvs-wk.local>
Date: Mon, 16 Sep 2024 16:19:47 -0700
Subject: [PATCH 04/14] ci fix

---
 e2e/server_test.go | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/e2e/server_test.go b/e2e/server_test.go
index 7c9f3233..a1f639d0 100644
--- a/e2e/server_test.go
+++ b/e2e/server_test.go
@@ -1,11 +1,12 @@
 package e2e_test
 
 import (
-	"github.com/Layr-Labs/eigenda-proxy/client"
 	"strings"
 	"testing"
 	"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"

From 1be6eb1273fe2ba94f2a111b150861aab00111e0 Mon Sep 17 00:00:00 2001
From: anupsv <asv@asvs-wk.local>
Date: Mon, 16 Sep 2024 18:51:30 -0700
Subject: [PATCH 05/14] removing unwanted assert

---
 e2e/server_test.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/e2e/server_test.go b/e2e/server_test.go
index a1f639d0..1c087108 100644
--- a/e2e/server_test.go
+++ b/e2e/server_test.go
@@ -139,7 +139,6 @@ func TestProxyClient(t *testing.T) {
 		t.Log("Setting input data on proxy server...")
 		_, err := daClient.SetData(ts.Ctx, testPreimage)
 		require.NoError(t, err)
-		assert.True(t, !isPanic(err.Error()))
 	})
 
 	t.Run("unicode preimage set data case", func(t *testing.T) {

From 933aa34b99947abb746f621ab08ae8f4e6cc565a Mon Sep 17 00:00:00 2001
From: anupsv <asv@asvs-wk.local>
Date: Mon, 16 Sep 2024 19:06:12 -0700
Subject: [PATCH 06/14] more fixes to tests

---
 e2e/server_test.go | 14 +++++---------
 1 file changed, 5 insertions(+), 9 deletions(-)

diff --git a/e2e/server_test.go b/e2e/server_test.go
index 1c087108..f55022bb 100644
--- a/e2e/server_test.go
+++ b/e2e/server_test.go
@@ -107,9 +107,9 @@ func TestOptimismClientWithGenericCommitment(t *testing.T) {
 }
 
 func TestProxyClient(t *testing.T) {
-	if !runIntegrationTests && !runTestnetIntegrationTests {
-		t.Skip("Skipping test as INTEGRATION or TESTNET env var not set")
-	}
+	//if !runIntegrationTests && !runTestnetIntegrationTests {
+	//	t.Skip("Skipping test as INTEGRATION or TESTNET env var not set")
+	//}
 
 	t.Parallel()
 
@@ -146,13 +146,11 @@ func TestProxyClient(t *testing.T) {
 		t.Log("Setting input data on proxy server...")
 		_, err := daClient.SetData(ts.Ctx, testPreimage)
 		require.NoError(t, err)
-		assert.True(t, !isPanic(err.Error()))
 
 		testPreimage = []byte("§") // Empty preimage
 		t.Log("Setting input data on proxy server...")
 		_, err = daClient.SetData(ts.Ctx, testPreimage)
 		require.NoError(t, err)
-		assert.True(t, !isPanic(err.Error()))
 
 	})
 
@@ -161,7 +159,6 @@ func TestProxyClient(t *testing.T) {
 		t.Log("Setting input data on proxy server...")
 		_, err := daClient.SetData(ts.Ctx, testPreimage)
 		require.NoError(t, err)
-		assert.True(t, !isPanic(err.Error()))
 	})
 
 	t.Run("get data edge cases", func(t *testing.T) {
@@ -169,14 +166,13 @@ func TestProxyClient(t *testing.T) {
 		_, err := daClient.GetData(ts.Ctx, testCert)
 		require.Error(t, err)
 		assert.True(t, strings.Contains(err.Error(),
-			"received error response, code=400, msg = commitment is empty") && !isPanic(err.Error()))
+			"commitment is too short") && !isPanic(err.Error()))
 
 		testCert = []byte{1}
 		_, err = daClient.GetData(ts.Ctx, testCert)
 		require.Error(t, err)
 		assert.True(t, strings.Contains(err.Error(),
-			"received error response, code=500, msg = failed to decode DA cert to RLP format: EOF") &&
-			!isPanic(err.Error()))
+			"commitment is too short") && !isPanic(err.Error()))
 
 		testCert = []byte(e2e.RandString(10000))
 		_, err = daClient.GetData(ts.Ctx, testCert)

From 9209ce1440590ebf14d0d3062a9fc6a5779a0702 Mon Sep 17 00:00:00 2001
From: anupsv <asv@asvs-wk.local>
Date: Mon, 16 Sep 2024 19:09:39 -0700
Subject: [PATCH 07/14] removing commented code

---
 e2e/server_test.go | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/e2e/server_test.go b/e2e/server_test.go
index f55022bb..24cb71c3 100644
--- a/e2e/server_test.go
+++ b/e2e/server_test.go
@@ -107,9 +107,9 @@ func TestOptimismClientWithGenericCommitment(t *testing.T) {
 }
 
 func TestProxyClient(t *testing.T) {
-	//if !runIntegrationTests && !runTestnetIntegrationTests {
-	//	t.Skip("Skipping test as INTEGRATION or TESTNET env var not set")
-	//}
+	if !runIntegrationTests && !runTestnetIntegrationTests {
+		t.Skip("Skipping test as INTEGRATION or TESTNET env var not set")
+	}
 
 	t.Parallel()
 

From 10cfd7f806561ca6db6c81b5c339e30497fa8089 Mon Sep 17 00:00:00 2001
From: anupsv <asv@asvs-wk.local>
Date: Tue, 17 Sep 2024 10:04:36 -0700
Subject: [PATCH 08/14] separating tests for integration only

---
 e2e/server_test.go | 84 +++++++++++++++++++++++++++++++---------------
 1 file changed, 57 insertions(+), 27 deletions(-)

diff --git a/e2e/server_test.go b/e2e/server_test.go
index 24cb71c3..647f4a19 100644
--- a/e2e/server_test.go
+++ b/e2e/server_test.go
@@ -23,11 +23,19 @@ func isPanic(err string) bool {
 		strings.Contains(err, "nil pointer dereference")
 }
 
-func TestOptimismClientWithKeccak256Commitment(t *testing.T) {
-	if !runIntegrationTests && !runTestnetIntegrationTests {
-		t.Skip("Skipping test as INTEGRATION or TESTNET env var not set")
+func TestOptimismClientWithKeccak256CommitmentIntegration(t *testing.T) {
+	if !runIntegrationTests || runTestnetIntegrationTests {
+		t.Skip("Skipping test as TESTNET env set or INTEGRATION var not set")
 	}
 
+	// nil commitment. Should return an error but currently is not. This needs to be fixed by OP
+	// 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()))
+	// })
+
 	t.Parallel()
 
 	testCfg := e2e.TestConfig(useMemory())
@@ -36,17 +44,8 @@ func TestOptimismClientWithKeccak256Commitment(t *testing.T) {
 	ts, kill := e2e.CreateTestSuite(t, testCfg)
 	defer kill()
 
-	daClient := op_plasma.NewDAClient(ts.Address(), false, true)
 	daClientPcFalse := op_plasma.NewDAClient(ts.Address(), false, false)
 
-	// nil commitment. Should return an error but currently is not. This needs to be fixed by OP
-	// 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()))
-	// })
-
 	t.Run("input bad data to SetInput & GetInput", func(t *testing.T) {
 		testPreimage := []byte("") // Empty preimage
 		_, err := daClientPcFalse.SetInput(ts.Ctx, testPreimage)
@@ -64,7 +63,23 @@ func TestOptimismClientWithKeccak256Commitment(t *testing.T) {
 		// assert.False(t, strings.Contains(err.Error(), ": EOF") && !isPanic(err.Error()))
 	})
 
-	// nil commitment. Should return an error but currently not
+}
+
+func TestOptimismClientWithKeccak256Commitment(t *testing.T) {
+	if !runIntegrationTests && !runTestnetIntegrationTests {
+		t.Skip("Skipping test as INTEGRATION or TESTNET env var not set")
+	}
+
+	t.Parallel()
+
+	testCfg := e2e.TestConfig(useMemory())
+	testCfg.UseKeccak256ModeS3 = true
+
+	ts, kill := e2e.CreateTestSuite(t, testCfg)
+	defer kill()
+
+	daClient := op_plasma.NewDAClient(ts.Address(), false, true)
+
 	t.Run("normal case", func(t *testing.T) {
 		testPreimage := []byte(e2e.RandString(100))
 
@@ -106,7 +121,7 @@ func TestOptimismClientWithGenericCommitment(t *testing.T) {
 	require.Equal(t, testPreimage, preimage)
 }
 
-func TestProxyClient(t *testing.T) {
+func TestProxyClientIntegrationOnly(t *testing.T) {
 	if !runIntegrationTests && !runTestnetIntegrationTests {
 		t.Skip("Skipping test as INTEGRATION or TESTNET env var not set")
 	}
@@ -121,19 +136,6 @@ func TestProxyClient(t *testing.T) {
 	}
 	daClient := client.New(cfg)
 
-	t.Run("normal case case", func(t *testing.T) {
-		testPreimage := []byte(e2e.RandString(100))
-
-		t.Log("Setting input data on proxy server...")
-		blobInfo, err := daClient.SetData(ts.Ctx, testPreimage)
-		require.NoError(t, err)
-
-		t.Log("Getting input data from proxy server...")
-		preimage, err := daClient.GetData(ts.Ctx, blobInfo)
-		require.NoError(t, err)
-		require.Equal(t, testPreimage, preimage)
-	})
-
 	t.Run("single byte preimage set data case", func(t *testing.T) {
 		testPreimage := []byte{1} // Empty preimage
 		t.Log("Setting input data on proxy server...")
@@ -181,6 +183,34 @@ func TestProxyClient(t *testing.T) {
 			"failed to decode DA cert to RLP format: rlp: expected input list for verify.Certificate") &&
 			!isPanic(err.Error()))
 	})
+
+}
+
+func TestProxyClient(t *testing.T) {
+	if !runIntegrationTests && !runTestnetIntegrationTests {
+		t.Skip("Skipping test as INTEGRATION or TESTNET env var not set")
+	}
+
+	t.Parallel()
+
+	ts, kill := e2e.CreateTestSuite(t, e2e.TestConfig(useMemory()))
+	defer kill()
+
+	cfg := &client.Config{
+		URL: ts.Address(),
+	}
+	daClient := client.New(cfg)
+
+	testPreimage := []byte(e2e.RandString(100))
+
+	t.Log("Setting input data on proxy server...")
+	blobInfo, err := daClient.SetData(ts.Ctx, testPreimage)
+	require.NoError(t, err)
+
+	t.Log("Getting input data from proxy server...")
+	preimage, err := daClient.GetData(ts.Ctx, blobInfo)
+	require.NoError(t, err)
+	require.Equal(t, testPreimage, preimage)
 }
 
 func TestProxyServerWithLargeBlob(t *testing.T) {

From 8e5e6f7a0251594baa277bf0fa211de6daf35bf0 Mon Sep 17 00:00:00 2001
From: anupsv <asv@asvs-wk.local>
Date: Wed, 18 Sep 2024 12:24:08 -0700
Subject: [PATCH 09/14] changing test name and adding OP issue link

---
 e2e/server_test.go | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/e2e/server_test.go b/e2e/server_test.go
index 647f4a19..65186344 100644
--- a/e2e/server_test.go
+++ b/e2e/server_test.go
@@ -23,27 +23,27 @@ func isPanic(err string) bool {
 		strings.Contains(err, "nil pointer dereference")
 }
 
-func TestOptimismClientWithKeccak256CommitmentIntegration(t *testing.T) {
+func TestOpClientKeccak256MalformedInputs(t *testing.T) {
 	if !runIntegrationTests || runTestnetIntegrationTests {
 		t.Skip("Skipping test as TESTNET env set or INTEGRATION var not set")
 	}
 
-	// nil commitment. Should return an error but currently is not. This needs to be fixed by OP
-	// 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()))
-	// })
-
 	t.Parallel()
-
 	testCfg := e2e.TestConfig(useMemory())
 	testCfg.UseKeccak256ModeS3 = true
-
 	ts, kill := e2e.CreateTestSuite(t, testCfg)
 	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) {

From c7209a07f4f5ac3b25fc55ff7132c70d7b30ddd3 Mon Sep 17 00:00:00 2001
From: anupsv <anupsv@users.noreply.github.com>
Date: Thu, 19 Sep 2024 11:01:25 -0700
Subject: [PATCH 10/14] Update e2e/server_test.go

Co-authored-by: Samuel Laferriere <samlaf92@gmail.com>
---
 e2e/server_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/e2e/server_test.go b/e2e/server_test.go
index 65186344..7dfb7efc 100644
--- a/e2e/server_test.go
+++ b/e2e/server_test.go
@@ -18,7 +18,7 @@ func useMemory() bool {
 	return !runTestnetIntegrationTests
 }
 
-func isPanic(err string) bool {
+func isNilPtrDerefPanic(err string) bool {
 	return strings.Contains(err, "panic") && strings.Contains(err, "SIGSEGV") &&
 		strings.Contains(err, "nil pointer dereference")
 }

From 951092b2b4a36e0ce185f65bbb77821215f4557a Mon Sep 17 00:00:00 2001
From: anupsv <asv@asvs-wk.local>
Date: Thu, 19 Sep 2024 11:14:21 -0700
Subject: [PATCH 11/14] changed test name and fn name

---
 e2e/server_test.go | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/e2e/server_test.go b/e2e/server_test.go
index 7dfb7efc..5b51ebac 100644
--- a/e2e/server_test.go
+++ b/e2e/server_test.go
@@ -52,7 +52,7 @@ func TestOpClientKeccak256MalformedInputs(t *testing.T) {
 		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") && !isPanic(err.Error()))
+		assert.True(t, strings.Contains(err.Error(), "invalid input") && !isNilPtrDerefPanic(err.Error()))
 
 		// The below test panics silently.
 		input := op_plasma.NewGenericCommitment([]byte(""))
@@ -121,7 +121,7 @@ func TestOptimismClientWithGenericCommitment(t *testing.T) {
 	require.Equal(t, testPreimage, preimage)
 }
 
-func TestProxyClientIntegrationOnly(t *testing.T) {
+func TestProxyClientServerIntegration(t *testing.T) {
 	if !runIntegrationTests && !runTestnetIntegrationTests {
 		t.Skip("Skipping test as INTEGRATION or TESTNET env var not set")
 	}
@@ -168,20 +168,20 @@ func TestProxyClientIntegrationOnly(t *testing.T) {
 		_, err := daClient.GetData(ts.Ctx, testCert)
 		require.Error(t, err)
 		assert.True(t, strings.Contains(err.Error(),
-			"commitment is too short") && !isPanic(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") && !isPanic(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") &&
-			!isPanic(err.Error()))
+			!isNilPtrDerefPanic(err.Error()))
 	})
 
 }

From 6689c7a797cc7d44d2b93b059910458b1452c168 Mon Sep 17 00:00:00 2001
From: anupsv <asv@asvs-wk.local>
Date: Thu, 19 Sep 2024 11:26:58 -0700
Subject: [PATCH 12/14] test config changes

---
 e2e/server_test.go | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/e2e/server_test.go b/e2e/server_test.go
index 85a59bf8..d52c2a3e 100644
--- a/e2e/server_test.go
+++ b/e2e/server_test.go
@@ -31,7 +31,8 @@ func TestOpClientKeccak256MalformedInputs(t *testing.T) {
 	t.Parallel()
 	testCfg := e2e.TestConfig(useMemory())
 	testCfg.UseKeccak256ModeS3 = true
-	ts, kill := e2e.CreateTestSuite(t, testCfg)
+	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
@@ -154,7 +155,8 @@ func TestProxyClientServerIntegration(t *testing.T) {
 
 	t.Parallel()
 
-	ts, kill := e2e.CreateTestSuite(t, e2e.TestConfig(useMemory()))
+	tsConfig := e2e.TestSuiteConfig(t, e2e.TestConfig(useMemory()))
+	ts, kill := e2e.CreateTestSuite(t, tsConfig)
 	defer kill()
 
 	cfg := &client.Config{

From fcac380845f0f1fd0509b2806af22ed693a76585 Mon Sep 17 00:00:00 2001
From: anupsv <asv@asvs-wk.local>
Date: Thu, 19 Sep 2024 11:48:22 -0700
Subject: [PATCH 13/14] making the linter happy

---
 e2e/server_test.go | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/e2e/server_test.go b/e2e/server_test.go
index d52c2a3e..12f64f17 100644
--- a/e2e/server_test.go
+++ b/e2e/server_test.go
@@ -37,13 +37,13 @@ func TestOpClientKeccak256MalformedInputs(t *testing.T) {
 
 	// 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) {
+	// 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)
 

From 3e25323e0e5ba5a7f542144e0fde4a280046f159 Mon Sep 17 00:00:00 2001
From: anupsv <asv@asvs-wk.local>
Date: Thu, 19 Sep 2024 12:17:36 -0700
Subject: [PATCH 14/14] adding comments

---
 e2e/server_test.go | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/e2e/server_test.go b/e2e/server_test.go
index 12f64f17..a2431231 100644
--- a/e2e/server_test.go
+++ b/e2e/server_test.go
@@ -23,6 +23,8 @@ func isNilPtrDerefPanic(err string) bool {
 		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")
@@ -61,6 +63,7 @@ func TestOpClientKeccak256MalformedInputs(t *testing.T) {
 		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()))
 	})
 
@@ -148,6 +151,9 @@ 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")
@@ -165,19 +171,19 @@ func TestProxyClientServerIntegration(t *testing.T) {
 	daClient := client.New(cfg)
 
 	t.Run("single byte preimage set data case", func(t *testing.T) {
-		testPreimage := []byte{1} // Empty preimage
+		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("§§©ˆªªˆ˙√ç®∂§∞¶§ƒ¥√¨¥√¨¥ƒƒ©˙˜ø˜˜˜∫˙∫¥∫√†®®√稈¨˙ï") // Empty preimage
+		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("§") // Empty preimage
+		testPreimage = []byte("§") // single unicode character
 		t.Log("Setting input data on proxy server...")
 		_, err = daClient.SetData(ts.Ctx, testPreimage)
 		require.NoError(t, err)