Removing 0 as an undefined index

.github/workflows/bench.yml

@@ -41,7 +41,7 @@ jobs:
       - name: Setup go
         uses: actions/setup-go@v3
         with:
-          go-version: "1.19"
+          go-version: "1.20"
           cache: true
 
       - name: Build relic

.github/workflows/builds.yml

@@ -105,12 +105,14 @@ jobs:
     - name: Build/Push ${{ matrix.role }} images
       env:
         IMAGE_TAG: ${{ inputs.docker_tag }}
+        GITHUB_CREDS: "machine github.com login ${{ secrets.REPO_SYNC_USER }} password ${{ secrets.REPO_SYNC }}"
       run: |
         make docker-build-${{ matrix.role }} docker-push-${{ matrix.role }}
 
     - name: Build/Push ${{ matrix.role }} without_netgo images
       if: ${{ inputs.include_without_netgo }}
       env:
         IMAGE_TAG: ${{ inputs.docker_tag }}
+        GITHUB_CREDS: "machine github.com login ${{ secrets.REPO_SYNC_USER }} password ${{ secrets.REPO_SYNC }}"
       run: |
         make docker-build-${{ matrix.role }}-without-netgo docker-push-${{ matrix.role }}-without-netgo

.github/workflows/cd.yml

@@ -14,7 +14,7 @@ jobs:
     - name: Setup Go
       uses: actions/setup-go@v2
       with:
-        go-version: '1.19'
+        go-version: "1.20"
     - name: Checkout repo
       uses: actions/checkout@v2
     - name: Build relic

.github/workflows/ci.yml

@@ -16,9 +16,9 @@ on:
       - 'v[0-9]+.[0-9]+'
 
 env:
-  GO_VERSION: 1.19
+  GO_VERSION: "1.20"
 
-concurrency: 
+concurrency:
   group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.run_id }}
   cancel-in-progress: true
 
@@ -47,7 +47,7 @@ jobs:
       uses: golangci/golangci-lint-action@v3
       with:
         # Required: the version of golangci-lint is required and must be specified without patch version: we always use the latest patch version.
-        version: v1.49
+        version: v1.51
         args: -v --build-tags relic
         working-directory: ${{ matrix.dir }}
         # https://github.com/golangci/golangci-lint-action/issues/244
@@ -66,8 +66,8 @@ jobs:
           cache: true
       - name: Run tidy
         run: make tidy
-      - name: Emulator no relic check
-        run: make emulator-norelic-check
+      - name: code sanity check
+        run: make code-sanity-check
 
   shell-check:
     name: ShellCheck
@@ -149,7 +149,7 @@ jobs:
             make1: install-tools
             make2: test
             retries: 3
-            race: 1
+            race: 0
           - name: integration
             make1: install-tools
             make2: test
@@ -198,10 +198,14 @@ jobs:
           - make -C integration mvp-tests
           - make -C integration network-tests
           - make -C integration verification-tests
+          - make -C integration upgrades-tests
     runs-on: ubuntu-latest
     steps:
     - name: Checkout repo
       uses: actions/checkout@v3
+      with:
+          # all tags are needed for integration tests
+          fetch-depth: 0
     - name: Setup Go
       uses: actions/setup-go@v3
       with:
@@ -242,7 +246,7 @@ jobs:
     - name: Set up Localnet
       run: bash -c 'cd integration/localnet/ && make -e OBSERVER=2 bootstrap && make start-flow'
     - name: Ensure Observer is started
-      run: docker ps -f name=localnet_observer_1_1 | grep localnet_observer
+      run: docker ps -f name=localnet-observer_1-1 | grep localnet-observer
     - name: Get Client Version ensuring the client is provisioned
       run: docker run --network host localnet-client /go/flow -f /go/flow-localnet.json -n observer version
     - name: Wait for a default waiting period until a clean state

.github/workflows/flaky-test-debug.yml

@@ -5,7 +5,7 @@ on:
     branches:
       - '**/*flaky-test-debug*'
 env:
-  GO_VERSION: 1.19
+  GO_VERSION: "1.20"
 
 #concurrency:
 #  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.run_id }}
@@ -36,7 +36,7 @@ jobs:
         uses: golangci/golangci-lint-action@v3
         with:
           # Required: the version of golangci-lint is required and must be specified without patch version: we always use the latest patch version.
-          version: v1.49
+          version: v1.51
           args: -v --build-tags relic
           working-directory: ${{ matrix.dir }}
           # https://github.com/golangci/golangci-lint-action/issues/244

.github/workflows/semver-tags.yaml

@@ -0,0 +1,22 @@
+name: Verify Tag
+
+on:
+  push:
+    tags:
+      - '*'
+
+jobs:
+  SemVer-Check:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check if tag is SemVer compliant
+        # the tag should be in semver format, but can optionally be prepended by "any_text_with_slashes/" and "v"
+        # valid examples crypto/v0.24.5-fvm, tools/flaky_test_monitor/v0.23.5, v0.23.5, 0.23.5-fvm
+        run: |
+          TAG_NAME=${GITHUB_REF#refs/tags/}
+          if [[ "${TAG_NAME}" =~ ^(.+\/)*v?(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)(-((0|[1-9][0-9]*|[0-9]*[a-zA-Z-][0-9a-zA-Z-]*)(\.(0|[1-9][0-9]*|[0-9]*[a-zA-Z-][0-9a-zA-Z-]*))*))?(\+([0-9a-zA-Z-]+(\.[0-9a-zA-Z-]+)*))?$ ]]; then
+            echo "Tag $TAG_NAME is SemVer compliant"
+          else
+            echo "Tag $TAG_NAME is not SemVer compliant"
+            exit 1
+          fi

.github/workflows/test-monitor-flaky.yml

@@ -13,7 +13,7 @@ on:
 env:
   BIGQUERY_DATASET: production_src_flow_test_metrics
   BIGQUERY_TABLE: test_results
-  GO_VERSION: 1.19
+  GO_VERSION: "1.20"
 
 concurrency: 
   group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.run_id }}

.github/workflows/test-monitor-regular-skipped.yml

@@ -15,7 +15,7 @@ env:
   BIGQUERY_DATASET: production_src_flow_test_metrics
   BIGQUERY_TABLE: skipped_tests
   BIGQUERY_TABLE2: test_results
-  GO_VERSION: 1.19
+  GO_VERSION: "1.20"
 
 concurrency: 
   group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.run_id }}

.github/workflows/tools.yml

@@ -25,7 +25,7 @@ jobs:
     - name: Setup Go
       uses: actions/setup-go@v2
       with:
-        go-version: '1.19'
+        go-version: "1.20"
     - name: Set up Google Cloud SDK
       uses: google-github-actions/setup-gcloud@v1
       with:

.gitignore

@@ -68,6 +68,7 @@ go.work.sum
 
 # Ledger checkpoint status files
 **/checkpoint_status.json
+**/export_report.json
 
 # Local testing result files
 tps-results*.json

CODEOWNERS

@@ -23,11 +23,11 @@
 /module/chunking/** @ramtinms
 /integration/tests/verification @ramtinms @yhassanzadeh13
 
-# Ledger Stream 
+# Ledger Stream
 /ledger/** @ramtinms @AlexHentschel
 
-# FVM Stream 
-/fvm/**  @ramtinms @janezpodhostnik @pattyshack
+# FVM Stream
+/fvm/**  @ramtinms @janezpodhostnik
 
 # Networking Stream
 /network/** @yhassanzadeh13
@@ -45,11 +45,7 @@
 /tools/test_monitor/** @gomisha
 
 # Performance Stream
-/integration/benchmark/** @SaveTheRbtz @gomisha
-/integration/localnet/** @SaveTheRbtz
-/module/profiler/** @SaveTheRbtz @pattyshack
-/module/trace/** @SaveTheRbtz @pattyshack
-/module/tracer.go @SaveTheRbtz @pattyshack
+/integration/benchmark/** @gomisha
 
 # Execution Sync
 /module/executiondatasync/** @peterargue

CodingConventions.md

@@ -91,7 +91,7 @@ happy path is either
        Benign failure cases are represented as typed sentinel errors
        ([basic errors](https://pkg.go.dev/errors#New) and [higher-level errors](https://dev.to/tigorlazuardi/go-creating-custom-error-wrapper-and-do-proper-error-equality-check-11k7)),
        so we can do type checks.  
-   2. _exception: the error a potential symptom of internal state corruption_.  
+   2. _exception: the error is a potential symptom of internal state corruption_.  
       For example, a failed sanity check. In this case, the error is most likely fatal.
       <br /><br />
 
@@ -107,11 +107,71 @@ happy path is either
 where we treat everything beyond the known benign errors as critical failures. In unexpected failure cases, we assume that the vertex's in-memory state has been
 broken and proper functioning is no longer guaranteed. The only safe route of recovery is to restart the vertex from a previously persisted, safe state.
 Per convention, a vertex should throw any unexpected exceptions using the related [irrecoverable context](https://github.com/onflow/flow-go/blob/277b6515add6136946913747efebd508f0419a25/module/irrecoverable/irrecoverable.go).
-   * Many components in our BFT system can return benign errors (type (i)) and exceptions (type (ii))
-   * Use the special `irrecoverable.exception` [error type](https://github.com/onflow/flow-go/blob/master/module/irrecoverable/exception.go#L7-L26) to denote an unexpected error (and strip any sentinel information from the error stack)
-
-
-3. _Optional Simplification for components that solely return benign errors._
+   * Many components in our BFT system can return benign errors (type (i)) and irrecoverable exceptions (type (ii))
+
+3. **Whether a particular error is benign or an exception depends on the caller's context. Errors _cannot_ be categorized as benign or exception based on their type alone.**
+
+   ![Error Handling](/docs/ErrorHandling.png)
+
+   * For example, consider `storage.ErrNotFound` that could be returned by the storage lager, when querying a block by ID
+   (method [`Headers.ByBlockID(flow.Identifier)`](https://github.com/onflow/flow-go/blob/a918616c7b541b772c254e7eaaae3573561e6c0a/storage/headers.go#L15-L18)).
+   In many cases, `storage.ErrNotFound` is expected, for instance if a node is receiving a new block proposal and checks whether the parent has already been ingested
+   or needs to be requested from a different node. In contrast, if we are querying a block that we know is already finalized and the storage returns a `storage.ErrNotFound`
+   something is badly broken. 
+   * Use the special `irrecoverable.exception` [error type](https://github.com/onflow/flow-go/blob/master/module/irrecoverable/exception.go#L7-L26)
+     to denote an unexpected error (and strip any sentinel information from the error stack).
+
+     This is for any scenario when a higher-level function is interpreting a sentinel returned from a lower-level function as an exception.
+     To construct an example, lets look at our `storage.Blocks` API, which has a [`ByHeight` method](https://github.com/onflow/flow-go/blob/a918616c7b541b772c254e7eaaae3573561e6c0a/storage/blocks.go#L24-L26)
+     to retrieve _finalized_ blocks by height. The following could be a hypothetical implementation:
+      ```golang
+      // ByHeight retrieves the finalized block for the given height.
+      // From the perspective of the storage layer, the following errors are benign:
+      //   - storage.ErrNotFound if no finalized block at the given height is known
+      func ByHeight(height uint64) (*flow.Block, error) {
+          // Step 1: retrieve the ID of the finalized block for the given height. We expect
+          // `storage.ErrNotFound` during normal operations, if no block at height has been
+          // finalized. We just bubble this sentinel up, as it already has the expected type.
+          blockID, err := retrieveBlockIdByHeight(height)
+          if err != nil {
+              return nil, fmt.Errorf("could not query block by height: %w", err)
+          }
+
+          // Step 2: retrieve full block by ID. Function `retrieveBlockByID` returns
+          // `storage.ErrNotFound` in case no block with the given ID is known. In other parts
+          // of the code that also use `retrieveBlockByID`, this would be expected during normal
+          // operations. However, here we are querying a block, which the storage layer has
+          // already indexed. Failure to retrieve the block implies our storage is corrupted.
+          block, err := retrieveBlockByID(blockID)
+          if err != nil {
+              // We cannot bubble up `storage.ErrNotFound` as this would hide this irrecoverable
+              // failure behind a benign sentinel error. We use the `Exception` wrapper, which
+              // also implements the error `interface` but provides no `Unwrap` method. Thereby,
+              // the `err`s sentinel type is hidden from upstream type checks, and consequently 
+              // classified as unexpected, i.e. irrecoverable exceptions. 
+              return nil, irrecoverable.NewExceptionf("storage inconsistency, failed to" +
+                        "retrieve full block for indexed and finalized block %x: %w", blockID, err)
+          }
+          return block, nil
+      }
+      ```
+     Functions **may** use `irrecoverable.NewExceptionf` when:
+       - they are interpreting any error returning from a 3rd party module as unexpected
+       - they are reacting to an unexpected condition internal to their stack frame and returning a generic error
+
+     Functions **must** usd `irrecoverable.NewExceptionf` when:
+       - they are interpreting any documented sentinel error returned from a flow-go module as unexpected
+
+     For brief illustration, let us consider some function body, in which there are multiple subsequent calls to other lower-level functions.
+     In most scenarios, a particular sentinel type is either always or never expected during normal operations.  If it is expected,
+     then the sentinel type should be documented. If it is consistently not expected, the error should _not_ be mentioned in the 
+     function's godoc. In the absence of positive affirmation that `error` is an expected and benign sentinel, the error is to be
+     treated as an irrecoverable exception. So if a sentinel type `T` is consistently not expected throughout the function's body, make 
+     sure the sentinel `T` is not mentioned in the function's godoc. The latter is fully sufficient to classify `T` as an irrecoverable
+     exception.   
+
+
+5. _Optional Simplification for components that solely return benign errors._
    * In this case, you _can_ use untyped errors to represent benign error cases (e.g. using `fmt.Errorf`).
    * By using untyped errors, the code would be _breaking with our best practice guideline_ that benign errors should be represented as typed sentinel errors.
 Therefore, whenever all returned errors are benign, please clearly document this _for each public functions individually_.
@@ -160,7 +220,8 @@ For example, a statement like the following would be sufficient:
 * Handle errors at a level, where you still have enough context to decide whether the error is expected during normal
   operations.
 * Errors of unexpected types are indicators that the node's internal state might be corrupted.
-    - Use the special `irrecoverable.exception` [error type](https://github.com/onflow/flow-go/blob/master/module/irrecoverable/exception.go#L7-L26) at the point an unexpected error is being returned, or when an error returned from another function is interpreted as unexpected
+
+
 ### Anti-Pattern
 
 Continuing on a best-effort basis is not an option, i.e. the following is an anti-pattern in the context of Flow: