feat(coordinator): print version at startup (#800)

Co-authored-by: HAOYUatHZ <HAOYUatHZ@users.noreply.github.com>

.github/scripts/bump_version_dot_go.mjs

@@ -0,0 +1,37 @@
+import { URL } from "url";
+import { readFileSync, writeFileSync } from "fs";
+
+const versionFilePath = new URL(
+  "../../common/version/version.go",
+  import.meta.url
+).pathname;
+
+const versionFileContent = readFileSync(versionFilePath, { encoding: "utf-8" });
+
+const currentVersion = versionFileContent.match(
+  /var tag = "(?<version>v(?<major>\d+)\.(?<minor>\d+)\.(?<patch>\d+))"/
+);
+
+try {
+  parseInt(currentVersion.groups.major);
+  parseInt(currentVersion.groups.minor);
+  parseInt(currentVersion.groups.patch);
+} catch (err) {
+  console.error(new Error("Failed to parse version in version.go file"));
+  throw err;
+}
+
+// prettier-ignore
+const newVersion = `v${currentVersion.groups.major}.${currentVersion.groups.minor}.${parseInt(currentVersion.groups.patch) + 1}`;
+
+console.log(
+  `Bump version from ${currentVersion.groups.version} to ${newVersion}`
+);
+
+writeFileSync(
+  versionFilePath,
+  versionFileContent.replace(
+    `var tag = "${currentVersion.groups.version}"`,
+    `var tag = "${newVersion}"`
+  )
+);

.github/workflows/bump_version.yml

@@ -0,0 +1,61 @@
+name: Bump Version
+
+on:
+  pull_request:
+    branches: [develop]
+    types:
+      - opened
+      - reopened
+      - synchronize
+      - ready_for_review
+
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    outputs:
+      check-result: ${{ steps.check-diff.outputs.result }}
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+      - name: check diff
+        id: check-diff
+        run: |
+          set -euo pipefail
+
+          # fetch develop branch so that we can diff against later
+          git fetch origin develop
+
+          echo 'checking verion changes in diff...'
+
+          # check if version changed in version.go
+          # note: the grep will fail if use \d instead of [0-9]
+          git diff HEAD..origin/develop --text --no-ext-diff --unified=0 --no-prefix common/version/version.go | grep -E '^\+var tag = "v[0-9]+\.[0-9]+\.[0-9]+"$' && true
+
+          exit_code=$?
+
+          # auto bump if version is not bumped manually
+          echo '> require auto version bump?'
+
+          if [ $exit_code -eq 0 ]; then
+            echo '> no, already bumped'
+            echo "result=no-bump" >> "$GITHUB_OUTPUT"
+          else
+            echo '> yes'
+            echo "result=bump" >> "$GITHUB_OUTPUT"
+          fi
+  bump:
+    runs-on: ubuntu-latest
+    needs: check
+    if: needs.check.outputs.check-result == 'bump'
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+      - name: Install Node.js 16
+        uses: actions/setup-node@v3
+        with:
+          node-version: 16
+      - name: bump version in common/version/version.go
+        run: node .github/scripts/bump_version_dot_go.mjs
+      - uses: stefanzweifel/git-auto-commit-action@3ea6ae190baf489ba007f7c92608f33ce20ef04a
+        with:
+          commit_message: "chore: auto version bump [bot]"

common/version/version.go

@@ -6,7 +6,7 @@ import (
 	"strings"
 )
 
-var tag = "v4.1.46"
+var tag = "v4.1.49"
 
 var commit = func() string {
 	if info, ok := debug.ReadBuildInfo(); ok {

coordinator/cmd/app/app.go

@@ -71,6 +71,11 @@ func action(ctx *cli.Context) error {
 
 	apiSrv := apiServer(ctx, cfg, db, registry)
 
+	log.Info(
+		"coordinator start successfully",
+		"version", version.Version,
+	)
+
 	// Catch CTRL-C to ensure a graceful shutdown.
 	interrupt := make(chan os.Signal, 1)
 	signal.Notify(interrupt, os.Interrupt)

prover/cmd/app/app.go

@@ -52,9 +52,11 @@ func action(ctx *cli.Context) error {
 	r.Start()
 
 	defer r.Stop()
-	log.Info("prover start successfully",
+	log.Info(
+		"prover start successfully",
 		"name", cfg.ProverName, "type", cfg.Core.ProofType,
-		"publickey", r.PublicKey(), "version", version.Version)
+		"publickey", r.PublicKey(), "version", version.Version,
+	)
 
 	// Catch CTRL-C to ensure a graceful shutdown.
 	interrupt := make(chan os.Signal, 1)

prover/core/prover_test.go

@@ -13,6 +13,7 @@ import (
 	"github.com/scroll-tech/go-ethereum/core/types"
 	"github.com/stretchr/testify/assert"
 
+	scrollTypes "scroll-tech/common/types"
 	"scroll-tech/common/types/message"
 
 	"scroll-tech/prover/config"
@@ -20,15 +21,67 @@ import (
 )
 
 var (
-	paramsPath          = flag.String("params", "/assets/test_params", "params dir")
-	proofDumpPath       = flag.String("dump", "/assets/proof_data", "the path proofs dump to")
-	batchTaskDetailPath = flag.String("batch-task-detail", "/assets/traces/full_proof_1.json", "batch-task-detail")
+	paramsPath    = flag.String("params", "/assets/test_params", "params dir")
+	proofDumpPath = flag.String("dump", "/assets/proof_data", "the path proofs dump to")
+	tracePath1    = flag.String("trace1", "/assets/traces/1_transfer.json", "chunk trace 1")
+	tracePath2    = flag.String("trace2", "/assets/traces/10_transfer.json", "chunk trace 2")
 )
 
 func TestFFI(t *testing.T) {
 	as := assert.New(t)
 
-	batchTaskDetail := readBatchTaskDetail(*batchTaskDetailPath, as)
+	chunkProverConfig := &config.ProverCoreConfig{
+		DumpDir:    *proofDumpPath,
+		ParamsPath: *paramsPath,
+		ProofType:  message.ProofTypeChunk,
+	}
+	chunkProverCore, err := core.NewProverCore(chunkProverConfig)
+	as.NoError(err)
+	t.Log("Constructed chunk prover")
+
+	chunkTrace1 := readChunkTrace(*tracePath1, as)
+	chunkTrace2 := readChunkTrace(*tracePath2, as)
+	t.Log("Loaded chunk traces")
+
+	chunkInfo1, err := chunkProverCore.TracesToChunkInfo(chunkTrace1)
+	as.NoError(err)
+	chunkInfo2, err := chunkProverCore.TracesToChunkInfo(chunkTrace2)
+	as.NoError(err)
+	t.Log("Converted to chunk infos")
+
+	wrappedBlock1 := &scrollTypes.WrappedBlock{
+		Header:       chunkTrace1[0].Header,
+		Transactions: chunkTrace1[0].Transactions,
+		WithdrawRoot: chunkTrace1[0].WithdrawTrieRoot,
+	}
+	chunk1 := &scrollTypes.Chunk{Blocks: []*scrollTypes.WrappedBlock{wrappedBlock1}}
+	chunkHash1, err := chunk1.Hash(0)
+	as.NoError(err)
+	as.Equal(chunkInfo1.PostStateRoot, wrappedBlock1.Header.Root)
+	as.Equal(chunkInfo1.WithdrawRoot, wrappedBlock1.WithdrawRoot)
+	as.Equal(chunkInfo1.DataHash, chunkHash1)
+	t.Log("Successful to check chunk info 1")
+
+	wrappedBlock2 := &scrollTypes.WrappedBlock{
+		Header:       chunkTrace2[0].Header,
+		Transactions: chunkTrace2[0].Transactions,
+		WithdrawRoot: chunkTrace2[0].WithdrawTrieRoot,
+	}
+	chunk2 := &scrollTypes.Chunk{Blocks: []*scrollTypes.WrappedBlock{wrappedBlock2}}
+	chunkHash2, err := chunk2.Hash(chunk1.NumL1Messages(0))
+	as.NoError(err)
+	as.Equal(chunkInfo2.PostStateRoot, wrappedBlock2.Header.Root)
+	as.Equal(chunkInfo2.WithdrawRoot, wrappedBlock2.WithdrawRoot)
+	as.Equal(chunkInfo2.DataHash, chunkHash2)
+	t.Log("Successful to check chunk info 2")
+
+	chunkProof1, err := chunkProverCore.ProveChunk("chunk_proof1", chunkTrace1)
+	as.NoError(err)
+	t.Log("Generated and dumped chunk proof 1")
+
+	chunkProof2, err := chunkProverCore.ProveChunk("chunk_proof2", chunkTrace2)
+	as.NoError(err)
+	t.Log("Generated and dumped chunk proof 2")
 
 	batchProverConfig := &config.ProverCoreConfig{
 		DumpDir:    *proofDumpPath,
@@ -38,23 +91,13 @@ func TestFFI(t *testing.T) {
 	batchProverCore, err := core.NewProverCore(batchProverConfig)
 	as.NoError(err)
 
-	_, err = batchProverCore.ProveBatch("batch_proof", batchTaskDetail.ChunkInfos, batchTaskDetail.ChunkProofs)
+	chunkInfos := []*message.ChunkInfo{chunkInfo1, chunkInfo2}
+	chunkProofs := []*message.ChunkProof{chunkProof1, chunkProof2}
+	_, err = batchProverCore.ProveBatch("batch_proof", chunkInfos, chunkProofs)
 	as.NoError(err)
 	t.Log("Generated and dumped batch proof")
 }
 
-func readBatchTaskDetail(filePat string, as *assert.Assertions) *message.BatchTaskDetail {
-	f, err := os.Open(filePat)
-	as.NoError(err)
-	byt, err := io.ReadAll(f)
-	as.NoError(err)
-
-	d := &message.BatchTaskDetail{}
-	as.NoError(json.Unmarshal(byt, d))
-
-	return d
-}
-
 func readChunkTrace(filePat string, as *assert.Assertions) []*types.BlockTrace {
 	f, err := os.Open(filePat)
 	as.NoError(err)