Merge pull request #649 from openmina/develop

Merge `develop` into `main`

Author: tizoc

.github/workflows/docker.yaml

@@ -123,7 +123,7 @@ jobs:
             runs-on: ubuntu-arm64
         configuration:
           - build_configuration: compose
-          - build_configuration: block_producers
+          - build_configuration: staging
     runs-on: ${{ matrix.arch.runs-on }}
     steps:
       - name: Prepare
@@ -175,7 +175,7 @@ jobs:
         configuration:
           - build_configuration: compose
             tag_suffix: ""
-          - build_configuration: block_producers
+          - build_configuration: staging
             tag_suffix: "-producer-demo"
     runs-on: ubuntu-latest
     needs:

ARCHITECTURE.md

@@ -860,3 +860,93 @@ if let Some((callback, block_hash)) = callback_and_arg {
 
 dispatcher.push(SnarkBlockVerifyAction::Finish { req_id: *req_id });
 ```
+
+#### Callbacks instead of conditional dispatches
+
+A common pattern seen in the current code is conditional dispatches:
+
+```rust
+if store.dispatch(SomeAction) {
+    store.dispatch(SomeOtherAction);
+}
+```
+
+The equivalent with queueing is to use `dispatcher.push_if_enabled` which will return `true` if the enabling condition for that action returns `true`. This will work most of the time, but it is possible for the state to change between the time the action was enqueued and when it is finally going to be dispatched, so the enabling condition may not be `true` anymore. This means that the equivalence is not strict.
+
+A better approach is to add a callback to the first action. This ensures that the second action only happens when intended, avoiding the potential race condition of the state changing between enqueuing and dispatching.
+
+First a callback is added to the action:
+
+```diff
+ #[derive(Serialize, Deserialize, Debug, Clone)]
+ pub enum LedgerWriteAction {
+-    Init { request: LedgerWriteRequest },
++    Init {
++        request: LedgerWriteRequest,
++        on_init: redux::Callback<LedgerWriteRequest>,
++    },
+     Pending,
+     // ...
+```
+
+Then in the handling code is updated to dispatch the callback:
+
+```diff
+     match action {
+         LedgerAction::Write(a) => match a {
+-            LedgerWriteAction::Init { request } => {
+-                store.service.write_init(request);
++            LedgerWriteAction::Init { request, on_init } => {
++                store.service.write_init(request.clone());
+                 store.dispatch(LedgerWriteAction::Pending);
++                store.dispatch_callback(on_init, request);
+             }
+```
+
+Finally the dispatching of that action is update to provide a callback that will return the same action that was inside the body of the conditional dispatch:
+
+```diff
+-  if store.dispatch(LedgerWriteAction::Init {
++  store.dispatch(LedgerWriteAction::Init {
+       request: LedgerWriteRequest::StagedLedgerDiffCreate {
+           pred_block: pred_block.clone(),
+           global_slot_since_genesis: won_slot
+           // ...
+           supercharge_coinbase,
+           transactions_by_fee,
+       },
+-  }) {
+-      store.dispatch(BlockProducerAction::StagedLedgerDiffCreatePending);
+-  }
++      on_init: redux::callback!(
++          on_staged_ledger_diff_create_init(_request: LedgerWriteRequest) -> crate::Action {
++              BlockProducerAction::StagedLedgerDiffCreatePending
++          }
++      ),
++  });
+```
+
+In the above example the passed argument is not used, but for other callbacks it is useful. Consider this example where we need the block hash for the next action, which can be extracted from the data contained in the request:
+
+```diff
+-   if store.dispatch(LedgerWriteAction::Init {
++   store.dispatch(LedgerWriteAction::Init {
+        request: LedgerWriteRequest::BlockApply { block, pred_block },
+-   }) {
+-       store.dispatch(TransitionFrontierSyncAction::BlocksNextApplyPending {
+-           hash: hash.clone(),
+-       });
+-   }
++       on_init: redux::callback!(
++           on_block_next_apply_init(request: LedgerWriteRequest) -> crate::Action {
++               let LedgerWriteRequest::BlockApply { block, .. } = request
++               else {
++                   // Cannot happen because this is the same value we passed above
++                   unreachable!()
++               };
++               let hash = block.hash().clone();
++               TransitionFrontierSyncAction::BlocksNextApplyPending { hash }
++           }
++       ),
++   });
+```

CHANGELOG.md

@@ -7,6 +7,19 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.8.2] - 2024-09-06
+
+### Fixed
+
+- Include circuit blobs in docker images, required for block production.
+- Add missing bounds to ZkAppUri and TokenSymbol fields.
+- Various stability improvements to make sure the node will not crash in certain circumstances.
+
+### Changed
+
+- Root snarked ledger re-syncs now reuse the previously in-progress root snarked ledger instead of starting again from the next-epoch ledger.
+- Added `--libp2p-keypair=<path to json>` flag to specify encrypted secret key (with passphrase from `MINA_LIBP2P_PASS` environment variable).
+
 ## [0.8.1] - 2024-09-02
 
 ### Fixed
@@ -215,7 +228,8 @@ First public release.
 - Alpha version of the node which can connect and syncup to the berkeleynet network, and keep applying new blocks to maintain consensus state and ledger up to date.
 - Web-based frontend for the node.
 
-[Unreleased]: https://github.com/openmina/openmina/compare/v0.8.1...develop
+[Unreleased]: https://github.com/openmina/openmina/compare/v0.8.2...develop
+[0.8.2]: https://github.com/openmina/openmina/releases/tag/v0.8.1...v0.8.2
 [0.8.1]: https://github.com/openmina/openmina/releases/tag/v0.8.0...v0.8.1
 [0.8.0]: https://github.com/openmina/openmina/releases/tag/v0.7.0...v0.8.0
 [0.7.0]: https://github.com/openmina/openmina/releases/tag/v0.6.0...v0.7.0

Cargo.lock

@@ -46,6 +46,7 @@ mina-poseidon = {git = "https://github.com/openmina/proof-systems", branch = "le
 poly-commitment = {git = "https://github.com/openmina/proof-systems", branch = "ledger-newtypes-rampup4-vrf"}
 libp2p = { git = "https://github.com/openmina/rust-libp2p", rev = "5c44c7d9", default-features = false }
 vrf = { path = "vrf" }
+openmina-node-account = { path = "node/account" }
 redux = { git = "https://github.com/openmina/redux-rs.git", rev = "588dd76c", features = ["serde"] }
 serde = "1.0.190"
 serde_json = "1.0.107"