fn add_storage_initialization_layer(mut self, kind: LayerKind) -> anyhow::Result<Self> {
        let config = &self.config;
        let snapshot_recovery_config =
            config
                .optional
                .snapshots_recovery_enabled
                .then_some(SnapshotRecoveryConfig {
                    snapshot_l1_batch_override: config.experimental.snapshots_recovery_l1_batch,
                    drop_storage_key_preimages: config
                        .experimental
                        .snapshots_recovery_drop_storage_key_preimages,
                    object_store_config: config.optional.snapshots_recovery_object_store.clone(),
                });
        self.node.add_layer(ExternalNodeInitStrategyLayer {
            l2_chain_id: self.config.required.l2_chain_id,
            max_postgres_concurrency: self
                .config
                .optional
                .snapshots_recovery_postgres_max_concurrency,
            snapshot_recovery_config,
        });
        let mut layer = NodeStorageInitializerLayer::new();
        if matches!(kind, LayerKind::Precondition) {
            layer = layer.as_precondition();
        }
        self.node.add_layer(layer);
        Ok(self)
    }
This layer will make sure that the database is initialized correctly,
e.g.:
- genesis or snapshot recovery will be performed if it's required.
- we perform the storage rollback if required (e.g. if reorg is detected).

Depending on the `kind` provided, either a task or a precondition will be added.

*Important*: the task should be added by at most one component, because
it assumes unique control over the database. Multiple components adding this
layer in a distributed mode may result in the database corruption.

This task works in pair with precondition, which must be present in every component:
the precondition will prevent node from starting until the database is initialized.
core/bin/external_node/src/node_builder.rs