refactor(high-level): Don't require &mut Block to improve the API for developers

examples/actions.rs

@@ -20,7 +20,7 @@ fn main() -> anyhow::Result<()> {
 }
 
 async fn print_function_calls_to_my_account(
-    mut block: near_lake_primitives::block::Block,
+    block: near_lake_primitives::block::Block,
 ) -> anyhow::Result<()> {
     let block_height = block.block_height();
     let actions: Vec<&near_lake_primitives::actions::FunctionCall> = block

examples/nft_indexer.rs

@@ -24,10 +24,12 @@ fn main() -> anyhow::Result<()> {
     Ok(())
 }
 
-async fn handle_block(mut block: near_lake_primitives::block::Block) -> anyhow::Result<()> {
+async fn handle_block(block: near_lake_primitives::block::Block) -> anyhow::Result<()> {
     // Indexing lines START
     let nfts: Vec<NFTReceipt> = block
         .events() // fetching all the events that occurred in the block
+        .values()
+        .flatten()
         .filter(|event| event.standard() == "nep171")
         .filter(|event| event.event() == "nft_mint") // filter them by "nft_mint" event only
         .filter_map(|event| parse_event(event))

examples/with_context.rs

@@ -51,7 +51,7 @@ fn main() -> anyhow::Result<()> {
 }
 
 async fn print_function_calls_to_my_account(
-    mut block: near_lake_primitives::block::Block,
+    block: near_lake_primitives::block::Block,
     ctx: &FileContext,
 ) -> anyhow::Result<()> {
     let block_height = block.block_height();

examples/with_context_parent_tx_cache.rs

@@ -33,7 +33,7 @@ fn main() -> anyhow::Result<()> {
 }
 
 async fn print_function_call_tx_hash(
-    mut block: near_lake_primitives::block::Block,
+    block: near_lake_primitives::block::Block,
     ctx: &ParentTransactionCache,
 ) -> anyhow::Result<()> {
     // Cache has been updated before this function is called.

lake-context-derive/README.md

@@ -35,7 +35,7 @@ This will simplify your indexer function signature. It now needs only the contex
 
 ```ignore
 async fn handle_block(
-    mut block: Block,
+    block: Block,
     ctx: &MyContext,
 ) -> anyhow::Result<()> {
   // body

lake-context-derive/src/lib.rs

@@ -65,7 +65,7 @@ pub fn lake_context_derive(input: TokenStream) -> TokenStream {
     let expanded = quote! {
         // The generated impl.
         impl near_lake_framework::LakeContextExt for #name {
-            fn execute_before_run(&self, block: &mut near_lake_primitives::block::Block) {
+            fn execute_before_run(&self, block: &near_lake_primitives::block::Block) {
                 #( #calls_before_run )*
             }
 

lake-framework/Cargo.toml

@@ -22,8 +22,8 @@ tokio = { version = "1.1", features = ["sync", "time", "rt-multi-thread"] }
 tokio-stream = { version = "0.1" }
 tracing = "0.1.13"
 
-near-lake-primitives = { path = "../lake-primitives", version = "0.8.0-beta.2" }
-near-lake-context-derive = { path = "../lake-context-derive", version = "0.8.0-beta.2" }
+near-lake-primitives = { path = "../lake-primitives", version = "0.8.0-beta.3" }
+near-lake-context-derive = { path = "../lake-context-derive", version = "0.8.0-beta.3" }
 
 [dev-dependencies]
 aws-smithy-http = "0.60.0"

lake-framework/README.md

@@ -91,7 +91,7 @@ fn main() -> anyhow::Result<()> {
 }
 
 async fn print_function_call_tx_hash(
-    mut block: near_lake_primitives::block::Block,
+    block: near_lake_primitives::block::Block,
     ctx: &ParentTransactionCache,
 ) -> anyhow::Result<()> {
     // Cache has been updated before this function is called.

lake-framework/src/lib.rs

@@ -68,9 +68,9 @@ impl types::Lake {
             // concurrency 1
             let mut handlers = tokio_stream::wrappers::ReceiverStream::new(stream)
                 .map(|streamer_message| async {
-                    let mut block: near_lake_primitives::block::Block = streamer_message.into();
+                    let block: near_lake_primitives::block::Block = streamer_message.into();
 
-                    context.execute_before_run(&mut block);
+                    context.execute_before_run(&block);
 
                     let user_indexer_function_execution_result = f(block, context).await;
 
@@ -116,7 +116,7 @@ impl types::Lake {
         struct EmptyContext {}
 
         impl LakeContextExt for EmptyContext {
-            fn execute_before_run(&self, _block: &mut near_lake_primitives::block::Block) {}
+            fn execute_before_run(&self, _block: &near_lake_primitives::block::Block) {}
 
             fn execute_after_run(&self) {}
         }

lake-framework/src/types.rs

@@ -179,7 +179,7 @@ pub enum LakeError {
 /// struct PrinterContext;
 ///
 /// impl LakeContextExt for PrinterContext {
-///    fn execute_before_run(&self, block: &mut near_lake_primitives::block::Block) {
+///    fn execute_before_run(&self, block: &near_lake_primitives::block::Block) {
 ///       println!("Processing block {}", block.header().height());
 ///   }
 ///   fn execute_after_run(&self) {}
@@ -201,7 +201,7 @@ pub enum LakeError {
 /// // We need our context to do nothing before and after the indexing process.
 /// // The only purpose is to provide the database connection pool to the indexing process.
 /// impl LakeContextExt for ApplicationDataContext {
-///   fn execute_before_run(&self, block: &mut near_lake_primitives::block::Block) {}
+///   fn execute_before_run(&self, block: &near_lake_primitives::block::Block) {}
 ///   fn execute_after_run(&self) {}
 /// }
 ///
@@ -319,7 +319,7 @@ pub enum LakeError {
 /// And we didn't need to implement them in our `ApplicationDataContext` struct because `LakeContext` derive macro did it for us automatically.
 pub trait LakeContextExt {
     /// This method will be called before the indexing process is started.
-    fn execute_before_run(&self, block: &mut near_lake_primitives::block::Block);
+    fn execute_before_run(&self, block: &near_lake_primitives::block::Block);
     /// This method will be called after the indexing process is finished.
     fn execute_after_run(&self);
 }

lake-parent-transaction-cache/README.md

@@ -24,7 +24,7 @@ LakeBuilder::default()
 # }
 
 async fn handle_block(
-    mut block: Block,
+    block: Block,
     ctx: &ParentTransactionCache,
 ) -> anyhow::Result<()> {
     for action in block.actions() {

lake-parent-transaction-cache/src/lib.rs

@@ -62,7 +62,7 @@ impl LakeContextExt for ParentTransactionCache {
     /// The process to scan the [near_lake_primitives::Block](near_lake_framework::near_lake_primitives::block::Block) and update the cache
     /// with the new transactions and first expected receipts.
     /// The cache is used to find the parent transaction hash for a given receipt id.
-    fn execute_before_run(&self, block: &mut Block) {
+    fn execute_before_run(&self, block: &Block) {
         // Fill up the cache with new transactions and first expected receipts
         // We will try to skip the transactions related to the accounts we're not watching for.
         // Based on `accounts_id`