Add NEAR support for substreams init

- Create near-hello-world package with conversation handler
- Add NEAR-specific templates for substreams.yaml, protobuf, and Rust code
- Register NEAR hello world in server handler
- Use substreams-near v0.10 dependency
- Support NEAR block processing with transactions and receipts extraction

Author: codegen-sh[bot]

near-hello-world/convo.go

@@ -0,0 +1,95 @@
+package nearhelloworld
+
+import (
+	"encoding/json"
+	"fmt"
+	"regexp"
+
+	registry "github.com/pinax-network/graph-networks-libs/packages/golang/lib"
+	networks "github.com/streamingfast/firehose-networks"
+	codegen "github.com/streamingfast/substreams-codegen"
+	"github.com/streamingfast/substreams-codegen/base"
+	"github.com/streamingfast/substreams-codegen/loop"
+)
+
+type Convo struct {
+	*codegen.Conversation[*Project]
+}
+
+func New() codegen.Converser {
+	return &Convo{&codegen.Conversation[*Project]{
+		State: &Project{
+			ConversationState: base.ConversationState{
+				ChainName: "near",
+			},
+		},
+	}}
+}
+
+func init() {
+	codegen.RegisterConversation(
+		"near-hello-world",
+		"Example Substreams that reads NEAR blocks and extract data from transactions and receipts.",
+		"Use this example as a starting point to create your own custom Substreams, which indexes the data you need from the NEAR blockchain.",
+		New,
+		60,
+		"NEAR",
+	)
+}
+
+func (c *Convo) NextStep() loop.Cmd {
+	p := c.State
+	if p.Name == "" {
+		return cmd(codegen.AskProjectName{})
+	}
+
+	return cmd(codegen.RunGenerate{})
+}
+
+func (c *Convo) Update(msg loop.Msg) loop.Cmd {
+	switch msg := msg.(type) {
+	case codegen.MsgStart:
+		c.SetClientVersion(msg.Version)
+		var msgCmd loop.Cmd
+		if msg.Hydrate != nil {
+			if err := json.Unmarshal([]byte(msg.Hydrate.SavedState), &c.State); err != nil {
+				return loop.Quit(fmt.Errorf(`something went wrong, here's an error message to share with our devs (%s); we've notified them already`, err))
+			}
+
+			msgCmd = c.Msg().Message("Ok, I reloaded your state.").Cmd()
+		} else {
+			msgCmd = c.Msg().Message("Ok, let's start a new package.").Cmd()
+		}
+		return loop.Seq(msgCmd, c.NextStep())
+
+	case codegen.InputSubstreamsConsumptionChoice:
+		return c.HandleSubstreamsConsumptionChoice(msg.Value)
+
+	case codegen.InputSourceDownloaded:
+		return c.HandleDownloaded(msg.Value)
+
+	case codegen.AskProjectName:
+		return c.CmdAskProjectName()
+
+	case codegen.InputProjectName:
+		c.State.Name = msg.Value
+		return c.NextStep()
+
+	case codegen.RunGenerate:
+		return c.CmdGenerate(c.State.Generate)
+
+	case codegen.ReturnGenerate:
+		return c.CmdDownloadFiles(msg)
+	}
+
+	return loop.Quit(fmt.Errorf("invalid loop message: %T", msg))
+}
+
+var cmd = codegen.Cmd
+
+var nearNetworkRegexp = regexp.MustCompile(`^near`)
+
+func nearNetworks() []*registry.Network {
+	return networks.GetSubstreamsRegistry().Search(nearNetworkRegexp)
+}
+

near-hello-world/state.go

@@ -0,0 +1,29 @@
+package nearhelloworld
+
+import (
+	"embed"
+
+	codegen "github.com/streamingfast/substreams-codegen"
+	"github.com/streamingfast/substreams-codegen/base"
+)
+
+//go:embed templates/*
+var templatesFS embed.FS
+
+type Project struct {
+	base.ConversationState
+}
+
+func (p *Project) Generate() codegen.ReturnGenerate {
+	return codegen.GenerateTemplateTree(p, templatesFS, map[string]string{
+		"proto/mydata.proto.gotmpl":     "proto/mydata.proto",
+		"src/pb/mod.rs.gotmpl":          "src/pb/mod.rs",
+		"src/lib.rs.gotmpl":             "src/lib.rs",
+		"Cargo.toml.gotmpl":             "Cargo.toml",
+		".gitignore.gotmpl":             ".gitignore",
+		"substreams.yaml.gotmpl":        "substreams.yaml",
+		"README.md.gotmpl":              "README.md",
+		"common-templates/buf.gen.yaml": "buf.gen.yaml",
+	})
+}
+

near-hello-world/templates/.gitignore.gotmpl

@@ -0,0 +1,4 @@
+/target
+**/*.rs.bk
+Cargo.lock
+

near-hello-world/templates/Cargo.toml.gotmpl

@@ -0,0 +1,14 @@
+[package]
+name = "{{ .Name }}"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+substreams = "0.5"
+substreams-near = "0.10"
+prost = "0.11"
+prost-types = "0.11"
+

near-hello-world/templates/README.md.gotmpl

@@ -0,0 +1,25 @@
+# {{ .Name }}
+
+This Substreams extracts data from NEAR blockchain transactions and receipts.
+
+## Quick Start
+
+```bash
+# Build the substreams
+substreams build
+
+# Run the substreams
+substreams run substreams.yaml map_my_data -e near.streamingfast.io:443
+```
+
+## Generated Files
+
+- `substreams.yaml`: Substreams manifest
+- `proto/mydata.proto`: Protocol buffer definitions
+- `src/lib.rs`: Main Rust source code
+- `Cargo.toml`: Rust dependencies
+
+## Customization
+
+Modify the `map_my_data` function in `src/lib.rs` to extract the specific data you need from NEAR blocks.
+

near-hello-world/templates/proto/mydata.proto.gotmpl

@@ -0,0 +1,26 @@
+syntax = "proto3";
+
+package mydata.v1;
+
+import "google/protobuf/any.proto";
+import "google/protobuf/timestamp.proto";
+import "sf/near/type/v1/type.proto";
+
+message MyData {
+  uint64 block_number = 1;
+  google.protobuf.Timestamp timestamp = 2;
+  repeated NearTransaction transactions = 3;
+}
+
+message NearTransaction {
+  string signer_id = 1;
+  string receiver_id = 2;
+  repeated NearAction actions = 3;
+  string transaction_hash = 4;
+}
+
+message NearAction {
+  string action_type = 1;
+  google.protobuf.Any action_data = 2;
+}
+

near-hello-world/templates/src/lib.rs.gotmpl

@@ -0,0 +1,57 @@
+mod pb;
+
+use crate::pb::{
+    mydata::v1::{MyData, NearTransaction, NearAction},
+    sf::near::r#type::v1::Block,
+};
+use pb::mydata::v1 as mydata;
+use prost::Message;
+use prost_types::Timestamp;
+use substreams::Hex;
+
+#[substreams::handlers::map]
+fn map_my_data(block: Block) -> Result<mydata::MyData, substreams::errors::Error> {
+    let header = block.header.as_ref().unwrap();
+    
+    let mut transactions: Vec<NearTransaction> = Vec::new();
+    
+    // Process transactions from all shards
+    for shard in block.shards {
+        if let Some(chunk) = shard.chunk {
+            for tx_with_outcome in chunk.transactions {
+                let tx = tx_with_outcome.transaction.unwrap();
+                
+                let mut actions: Vec<NearAction> = Vec::new();
+                for action in tx.actions {
+                    // Convert action to our custom format
+                    // Note: This is a simplified example - you would need to handle
+                    // different action types (CreateAccount, DeployContract, FunctionCall, etc.)
+                    let action_data = NearAction {
+                        action_type: "Unknown".to_string(), // You would determine the actual action type
+                        action_data: None, // You would serialize the actual action data
+                    };
+                    actions.push(action_data);
+                }
+                
+                let near_tx = NearTransaction {
+                    signer_id: tx.signer_id,
+                    receiver_id: tx.receiver_id,
+                    actions,
+                    transaction_hash: Hex::encode(&tx.hash.unwrap().bytes),
+                };
+                
+                transactions.push(near_tx);
+            }
+        }
+    }
+
+    Ok(MyData {
+        block_number: header.height,
+        timestamp: Some(Timestamp {
+            seconds: (header.timestamp / 1_000_000_000) as i64,
+            nanos: (header.timestamp % 1_000_000_000) as i32,
+        }),
+        transactions,
+    })
+}
+

near-hello-world/templates/src/pb/mod.rs.gotmpl

@@ -0,0 +1,17 @@
+// @generated
+pub mod mydata {
+    pub mod v1 {
+        include!(concat!(env!("OUT_DIR"), "/mydata.v1.rs"));
+    }
+}
+
+pub mod sf {
+    pub mod near {
+        pub mod r#type {
+            pub mod v1 {
+                include!(concat!(env!("OUT_DIR"), "/sf.near.type.v1.rs"));
+            }
+        }
+    }
+}
+

near-hello-world/templates/substreams.yaml.gotmpl

@@ -0,0 +1,30 @@
+specVersion: v0.1.0
+package:
+  name: my_project
+  version: v0.1.0
+
+protobuf:
+  files:
+    - mydata.proto
+  importPaths:
+    - ./proto
+  excludePaths:
+    - sf/substreams
+    - google
+
+binaries:
+  default:
+    type: wasm/rust-v1
+    file: ./target/wasm32-unknown-unknown/release/substreams.wasm
+
+modules:
+ - name: map_my_data
+   kind: map
+   initialBlock: 9820210
+   inputs:
+   - source: sf.near.type.v1.Block
+   output:
+    type: proto:mydata.v1.MyData
+
+network: {{ .ChainName }}
+

server/handler_convo.go

@@ -28,6 +28,7 @@ import (
 	_ "github.com/streamingfast/substreams-codegen/injective-hello-world"
 	_ "github.com/streamingfast/substreams-codegen/mantra-events"
 	_ "github.com/streamingfast/substreams-codegen/mantra-hello-world"
+	_ "github.com/streamingfast/substreams-codegen/near-hello-world"
 	_ "github.com/streamingfast/substreams-codegen/sol-anchor"
 	_ "github.com/streamingfast/substreams-codegen/sol-hello-world"
 	_ "github.com/streamingfast/substreams-codegen/sol-transactions"