Merge from upstream v0.4.0-beta10

.github/workflows/test-e2e.yml

@@ -39,7 +39,7 @@ jobs:
       run: |
         echo "deb [trusted=yes] https://apt.fury.io/kurtosis-tech/ /" | sudo tee /etc/apt/sources.list.d/kurtosis.list
         sudo apt update
-        sudo apt install kurtosis-cli=1.3.0
+        sudo apt install kurtosis-cli=1.4.1
         kurtosis version
 
     - name: Disable kurtosis analytics
@@ -70,7 +70,7 @@ jobs:
       with:
         repository: 0xPolygon/kurtosis-cdk
         path: "kurtosis-cdk"
-        ref: "v0.2.15"
+        ref: "v0.2.19"
 
     - name: Setup Bats and bats libs
       uses: bats-core/[email protected]

.github/workflows/test-resequence.yml

@@ -86,22 +86,20 @@ jobs:
         working-directory: ./cdk-erigon
         run: .github/scripts/test_resequence.sh
 
-      - name: Prepare logs
-        if: always()
-        working-directory: ./kurtosis-cdk
+      - name: Dump enclave logs
+        if: failure()
+        run: kurtosis dump ./dump
+
+      - name: Generate archive name
+        if: failure()
         run: |
-          mkdir -p ci_logs
-          cd ci_logs
-          kurtosis service logs cdk-v1 cdk-erigon-node-001 --all > cdk-erigon-node-001.log
-          kurtosis service logs cdk-v1 cdk-erigon-sequencer-001 --all > cdk-erigon-sequencer-001.log
-          kurtosis service logs cdk-v1 zkevm-agglayer-001 --all > zkevm-agglayer-001.log
-          kurtosis service logs cdk-v1 zkevm-prover-001 --all > zkevm-prover-001.log
-          kurtosis service logs cdk-v1 cdk-node-001 --all > cdk-node-001.log
-          kurtosis service logs cdk-v1 zkevm-bridge-service-001 --all > zkevm-bridge-service-001.log
+          archive_name="dump_run_with_args_${{matrix.e2e-group}}_${{ github.run_id }}"
+          echo "ARCHIVE_NAME=${archive_name}" >> "$GITHUB_ENV"
+          echo "Generated archive name: ${archive_name}"
 
       - name: Upload logs
-        if: always()
+        if: failure()
         uses: actions/upload-artifact@v4
         with:
-          name: logs_${{ github.run_id }}
-          path: ./kurtosis-cdk/ci_logs
+          name: ${{ env.ARCHIVE_NAME }}
+          path: ./dump

.golangci.yml

@@ -49,6 +49,8 @@ linters-settings:
   gocritic:
     enabled-checks:
       - ruleguard
+    disabled-checks:
+      - ifElseChain
   revive:
     rules:
       - name: exported

agglayer/client.go

@@ -15,14 +15,22 @@ import (
 
 const errCodeAgglayerRateLimitExceeded int = -10007
 
-var ErrAgglayerRateLimitExceeded = fmt.Errorf("agglayer rate limit exceeded")
+var (
+	ErrAgglayerRateLimitExceeded = fmt.Errorf("agglayer rate limit exceeded")
+	jSONRPCCall                  = rpc.JSONRPCCall
+)
+
+type AggLayerClientGetEpochConfiguration interface {
+	GetEpochConfiguration() (*ClockConfiguration, error)
+}
 
 // AgglayerClientInterface is the interface that defines the methods that the AggLayerClient will implement
 type AgglayerClientInterface interface {
 	SendTx(signedTx SignedTx) (common.Hash, error)
 	WaitTxToBeMined(hash common.Hash, ctx context.Context) error
 	SendCertificate(certificate *SignedCertificate) (common.Hash, error)
 	GetCertificateHeader(certificateHash common.Hash) (*CertificateHeader, error)
+	AggLayerClientGetEpochConfiguration
 }
 
 // AggLayerClient is the client that will be used to interact with the AggLayer
@@ -91,7 +99,9 @@ func (c *AggLayerClient) WaitTxToBeMined(hash common.Hash, ctx context.Context)
 
 // SendCertificate sends a certificate to the AggLayer
 func (c *AggLayerClient) SendCertificate(certificate *SignedCertificate) (common.Hash, error) {
-	response, err := rpc.JSONRPCCall(c.url, "interop_sendCertificate", certificate)
+	certificateToSend := certificate.CopyWithDefaulting()
+
+	response, err := rpc.JSONRPCCall(c.url, "interop_sendCertificate", certificateToSend)
 	if err != nil {
 		return common.Hash{}, err
 	}
@@ -128,3 +138,23 @@ func (c *AggLayerClient) GetCertificateHeader(certificateHash common.Hash) (*Cer
 
 	return result, nil
 }
+
+// GetEpochConfiguration returns the clock configuration of AggLayer
+func (c *AggLayerClient) GetEpochConfiguration() (*ClockConfiguration, error) {
+	response, err := jSONRPCCall(c.url, "interop_getEpochConfiguration")
+	if err != nil {
+		return nil, err
+	}
+
+	if response.Error != nil {
+		return nil, fmt.Errorf("GetEpochConfiguration code=%d msg=%s", response.Error.Code, response.Error.Message)
+	}
+
+	var result *ClockConfiguration
+	err = json.Unmarshal(response.Result, &result)
+	if err != nil {
+		return nil, err
+	}
+
+	return result, nil
+}

agglayer/client_test.go

@@ -0,0 +1,76 @@
+package agglayer
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/0xPolygon/cdk-rpc/rpc"
+	"github.com/stretchr/testify/require"
+)
+
+const (
+	testURL = "http://localhost:8080"
+)
+
+func TestExploratoryClient(t *testing.T) {
+	t.Skip("This test is for exploratory purposes only")
+	sut := NewAggLayerClient("http://127.0.0.1:32853")
+	config, err := sut.GetEpochConfiguration()
+	require.NoError(t, err)
+	require.NotNil(t, config)
+	fmt.Printf("Config: %s", config.String())
+}
+
+func TestGetEpochConfigurationResponseWithError(t *testing.T) {
+	sut := NewAggLayerClient(testURL)
+	response := rpc.Response{
+		Error: &rpc.ErrorObject{},
+	}
+	jSONRPCCall = func(url, method string, params ...interface{}) (rpc.Response, error) {
+		return response, nil
+	}
+	clockConfig, err := sut.GetEpochConfiguration()
+	require.Nil(t, clockConfig)
+	require.Error(t, err)
+}
+
+func TestGetEpochConfigurationResponseBadJson(t *testing.T) {
+	sut := NewAggLayerClient(testURL)
+	response := rpc.Response{
+		Result: []byte(`{`),
+	}
+	jSONRPCCall = func(url, method string, params ...interface{}) (rpc.Response, error) {
+		return response, nil
+	}
+	clockConfig, err := sut.GetEpochConfiguration()
+	require.Nil(t, clockConfig)
+	require.Error(t, err)
+}
+
+func TestGetEpochConfigurationErrorResponse(t *testing.T) {
+	sut := NewAggLayerClient(testURL)
+
+	jSONRPCCall = func(url, method string, params ...interface{}) (rpc.Response, error) {
+		return rpc.Response{}, fmt.Errorf("unittest error")
+	}
+	clockConfig, err := sut.GetEpochConfiguration()
+	require.Nil(t, clockConfig)
+	require.Error(t, err)
+}
+
+func TestGetEpochConfigurationOkResponse(t *testing.T) {
+	sut := NewAggLayerClient(testURL)
+	response := rpc.Response{
+		Result: []byte(`{"epoch_duration": 1, "genesis_block": 1}`),
+	}
+	jSONRPCCall = func(url, method string, params ...interface{}) (rpc.Response, error) {
+		return response, nil
+	}
+	clockConfig, err := sut.GetEpochConfiguration()
+	require.NotNil(t, clockConfig)
+	require.NoError(t, err)
+	require.Equal(t, ClockConfiguration{
+		EpochDuration: 1,
+		GenesisBlock:  1,
+	}, *clockConfig)
+}