feat(view): add read-only view fn entry points (V15)

Implements V15 `view fn` block: a top-level program component that reads
finalize-store state off-consensus and returns plaintext to external callers.
Allowed reads cover mappings, vectors, storage, `block.height`, and
`network.id`; writes, `async`, `call`, and `block.timestamp` are rejected.
View fns are leaves (snarkVM rejects `call` inside a view body) but can be
called from `final {}` blocks, `final fn` helpers, and hoisted `Finalize`
bodies. Cross-program views go through `is_cross_program_call_target` to
survive the inliner and monomorphizer. Interface conformance enforces
View↔View and Fn↔(Fn|EntryPoint).

Bumps snarkVM to 088684ed (PR #3253 head): finalize-calls-view plus
`many0` view bodies, so empty views compile to valid Aleo bytecode with
no dummy filler.

closes #29419

Author: Mohammad Fawaz

Cargo.lock

@@ -54,8 +54,8 @@ num-traits         = "0.2"
 once_cell          = "1.21"
 parking_lot        = "0.12"
 paste              = "1.0"
-rand               = { version = "0.8", default-features = false }
-rand_chacha        = { version = "0.3", default-features = false }
+rand               = { version = "0.10", default-features = false }
+rand_chacha        = { version = "0.10", default-features = false }
 rayon              = "1.11"
 regex              = "1.11"
 reqwest            = { version = "0.13", features = ["blocking", "json"] }
@@ -69,7 +69,14 @@ serial_test        = "3.1"
 sha2               = "0.10"
 similar            = "2.6"
 # We enable "test_consensus_heights" to give developers freedom to set custom consensus version upgrade heights and "test_targets" because the devnode's genesis block was created with the same feature flag.
-snarkvm            = { version = "4.6.0", features = [ "test_consensus_heights", "dev_skip_checks", "test_targets" ] }
+# TODO: switch back to a published version once a release is cut after snarkVM PRs #3238 (read-only `view` functions, V15), #3257 (`query` → `view` rename), and #3253 (finalize-calls-view) merge into `staging`.
+# `history` is required to compile `Process::evaluate_view_with_history`, the public-facing view entry point.
+snarkvm            = { git = "https://github.com/ProvableHQ/snarkVM.git", rev = "d4c570003d86b6abf0c0ba4b5c025ee3d4e46b4c", features = [ "test_consensus_heights", "dev_skip_checks", "test_targets", "history" ] }
+# Wasm-friendly snarkVM subsets pinned at the same rev as the umbrella crate; used by
+# `leo-ast` and `leo-disassembler` on `wasm32-unknown-unknown` where the full `snarkvm`
+# crate pulls in native-only ledger/package code.
+snarkvm-console = { git = "https://github.com/ProvableHQ/snarkVM.git", rev = "d4c570003d86b6abf0c0ba4b5c025ee3d4e46b4c", default-features = false, features = [ "account", "program", "types", "dev_skip_checks", "test_consensus_heights", "test_targets", "wasm" ] }
+snarkvm-synthesizer-program = { git = "https://github.com/ProvableHQ/snarkVM.git", rev = "d4c570003d86b6abf0c0ba4b5c025ee3d4e46b4c", features = [ "wasm" ] }
 sys-info           = "0.9"
 tempfile           = "3.20"
 thiserror          = "2.0"

Cargo.toml

@@ -51,6 +51,11 @@ pub struct Program {
     /// Public entry points (program functions only, not internal helpers).
     /// Compiled to Aleo `transition`s.
     pub functions: Vec<Function>,
+    /// Read-only `view fn` entry points (V15). Compiled to Aleo `view` blocks.
+    /// Off-consensus, plaintext-only inputs and outputs, no transactions or fees.
+    /// Defaults to empty for backwards compatibility with pre-V15 ABI consumers.
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub views: Vec<Function>,
 }
 
 /// The ABI for a single Leo interface.
@@ -65,8 +70,11 @@ pub struct Interface {
     pub path: Path,
     /// Inherited interfaces, by reference. Not flattened.
     pub parents: Vec<InterfaceRef>,
-    /// Locally declared function prototypes.
+    /// Locally declared function prototypes (`fn`).
     pub functions: Vec<Function>,
+    /// Locally declared view-function prototypes (`view fn`).
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub views: Vec<Function>,
     /// Locally declared record prototypes.
     pub records: Vec<Record>,
     /// Locally declared mapping prototypes.

crates/abi-types/src/lib.rs

@@ -91,8 +91,15 @@ pub fn generate(aleo: &ast::AleoProgram) -> abi::Program {
         .map(|(_, f)| convert_function_stub(f, &record_names))
         .collect();
 
+    let views = aleo
+        .functions
+        .iter()
+        .filter(|(_, f)| f.variant.is_view())
+        .map(|(_, f)| convert_function_stub(f, &record_names))
+        .collect();
+
     let mut program =
-        abi::Program { program, implements: vec![], structs, records, mappings, storage_variables, functions };
+        abi::Program { program, implements: vec![], structs, records, mappings, storage_variables, functions, views };
 
     // Prune types not used in the public interface.
     prune_non_interface_types(&mut program);

crates/abi/src/aleo.rs

@@ -382,8 +382,20 @@ fn build_interface(
     let parents: Vec<abi::InterfaceRef> =
         iface.parents.iter().filter_map(|(_, ty)| interface_ref_from_type(ty, &program)).collect();
 
-    let functions: Vec<abi::Function> =
-        iface.functions.iter().map(|(_, proto)| convert_function_prototype(proto, iface, cs)).collect();
+    // Split prototypes by variant so view fns appear in their own ABI bucket,
+    // parallel to how `Program.functions` and `Program.views` are split.
+    let functions: Vec<abi::Function> = iface
+        .functions
+        .iter()
+        .filter(|(_, proto)| !proto.variant.is_view())
+        .map(|(_, proto)| convert_function_prototype(proto, iface, cs))
+        .collect();
+    let views: Vec<abi::Function> = iface
+        .functions
+        .iter()
+        .filter(|(_, proto)| proto.variant.is_view())
+        .map(|(_, proto)| convert_function_prototype(proto, iface, cs))
+        .collect();
 
     let records: Vec<abi::Record> = iface.records.iter().map(|(_, proto)| convert_record_prototype(proto)).collect();
 
@@ -393,9 +405,18 @@ fn build_interface(
         iface.storages.iter().map(convert_storage_variable_prototype).collect();
 
     // Collect transitively referenced structs from the composite source.
-    let structs = collect_interface_structs(&program, &functions, &records, &mappings, &storage_variables, cs);
-
-    abi::Interface { name, program, path, parents, functions, records, mappings, storage_variables, structs }
+    // Pass both `functions` and `views` so that types referenced only by view
+    // fn signatures are still pulled into the interface's struct set.
+    let structs = collect_interface_structs(
+        &program,
+        functions.iter().chain(views.iter()),
+        &records,
+        &mappings,
+        &storage_variables,
+        cs,
+    );
+
+    abi::Interface { name, program, path, parents, functions, views, records, mappings, storage_variables, structs }
 }
 
 // ------------------------------------------------------------------------- //
@@ -501,17 +522,17 @@ fn convert_function_output(ty: &ast::Type, iface: &ast::Interface, cs: &Composit
 ///
 /// Only includes structs defined in the same program as the interface; external
 /// struct references remain as `StructRef` with a program field.
-fn collect_interface_structs(
+fn collect_interface_structs<'a>(
     program_name: &str,
-    functions: &[abi::Function],
+    functions: impl IntoIterator<Item = &'a abi::Function>,
     records: &[abi::Record],
     mappings: &[abi::Mapping],
     storage_variables: &[abi::StorageVariable],
     cs: &CompositeSource<'_>,
 ) -> Vec<abi::Struct> {
     let mut used_types: HashSet<abi::Path> = HashSet::new();
 
-    // Seed from functions.
+    // Seed from functions (and views — caller chains them in).
     for function in functions {
         for cp in &function.const_parameters {
             collect_from_plaintext(&cp.ty, program_name, &mut used_types);

crates/abi/src/interfaces.rs

@@ -80,10 +80,14 @@ pub fn generate(ast: &ast::Program) -> abi::Program {
     let functions =
         scope.functions.iter().filter(|(_, f)| f.variant.is_entry()).map(|(_, f)| convert_function(f, &ctx)).collect();
 
+    let views =
+        scope.functions.iter().filter(|(_, f)| f.variant.is_view()).map(|(_, f)| convert_function(f, &ctx)).collect();
+
     let implements: Vec<abi::InterfaceRef> =
         scope.parents.iter().filter_map(|(_, ty)| interface_ref_from_type(ty, &program)).collect();
 
-    let mut program = abi::Program { program, implements, structs, records, mappings, storage_variables, functions };
+    let mut program =
+        abi::Program { program, implements, structs, records, mappings, storage_variables, functions, views };
 
     // Prune types not used in the public interface.
     prune_non_interface_types(&mut program);
@@ -310,7 +314,7 @@ pub fn prune_non_interface_types(program: &mut abi::Program) {
     let program_name = &program.program;
 
     // Phase 1: Collect from interface items
-    for function in &program.functions {
+    for function in program.functions.iter().chain(program.views.iter()) {
         for input in &function.inputs {
             collect_from_function_input(&input.ty, program_name, &mut used_types);
         }

crates/abi/src/lib.rs

@@ -36,13 +36,5 @@ snarkvm         = { workspace = true }
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 getrandom = { version = "0.2", features = [ "js" ] }
-snarkvm-console = { version = "=4.6.1", default-features = false, features = [
-  "account",
-  "program",
-  "types",
-  "dev_skip_checks",
-  "test_consensus_heights",
-  "test_targets",
-  "wasm",
-] }
-snarkvm-synthesizer-program = { version = "=4.6.1", features = [ "wasm" ] }
+snarkvm-console = { workspace = true }
+snarkvm-synthesizer-program = { workspace = true }

crates/ast/Cargo.toml

@@ -140,6 +140,7 @@ impl fmt::Display for Function {
             Variant::Fn => write!(f, "fn ")?,
             Variant::Finalize => write!(f, "finalize ")?,
             Variant::EntryPoint => write!(f, "fn ")?,
+            Variant::View => write!(f, "view fn ")?,
         }
 
         write!(f, "{}", self.identifier)?;

crates/ast/src/functions/mod.rs

@@ -18,19 +18,25 @@ use serde::{Deserialize, Serialize};
 
 use std::fmt;
 
-/// Functions are always one of six variants.
-/// A transition function is permitted the ability to manipulate records.
-/// An asynchronous transition function is a transition function that calls an asynchronous function.
-/// A regular function is not permitted to manipulate records.
-/// An asynchronous function contains on-chain operations.
-/// An inline function is directly copied at the call site.
+/// The kind of a function definition.
+///
+/// - `Fn`: a regular function, callable from other Leo code.
+/// - `FinalFn`: a `final fn`, runs in the on-chain finalize context.
+/// - `EntryPoint`: a top-level program function — compiles to an Aleo
+///   `transition`. May or may not have a `final {}` block.
+/// - `Finalize`: the synthesized `final {}` block of an `EntryPoint`. Created
+///   during compilation, not written by the user.
+/// - `View`: a read-only `view fn` (V15). Top-level program component that
+///   reads finalize-store state and returns plaintext to external callers.
+///   Off-consensus, no transitions, no proofs, no state writes.
 #[derive(Copy, Clone, Debug, Default, Serialize, Deserialize, PartialEq, Eq)]
 pub enum Variant {
     #[default]
     Fn,
     FinalFn,
     EntryPoint,
     Finalize,
+    View,
 }
 
 impl Variant {
@@ -46,6 +52,17 @@ impl Variant {
     pub fn is_onchain(self) -> bool {
         matches!(self, Variant::Finalize | Variant::FinalFn)
     }
+
+    /// Returns true if the variant is a view function.
+    pub fn is_view(self) -> bool {
+        matches!(self, Variant::View)
+    }
+
+    /// Returns true if the variant is callable from outside the program
+    /// (transition entry point or view).
+    pub fn is_externally_callable(self) -> bool {
+        matches!(self, Variant::EntryPoint | Variant::View)
+    }
 }
 
 impl fmt::Display for Variant {
@@ -55,6 +72,7 @@ impl fmt::Display for Variant {
             Self::Fn => write!(f, "fn"),
             Self::EntryPoint => write!(f, "entry"),
             Self::Finalize => write!(f, "finalize"),
+            Self::View => write!(f, "view fn"),
         }
     }
 }

crates/ast/src/functions/variant.rs

@@ -27,6 +27,7 @@ use crate::{
     Output,
     TupleType,
     Type,
+    Variant,
     indent_display::Indent,
 };
 use itertools::Itertools;
@@ -97,6 +98,9 @@ crate::simple_node_impl!(StorageVariablePrototype);
 pub struct FunctionPrototype {
     /// Annotations on the function.
     pub annotations: Vec<Annotation>,
+    /// `Variant::Fn` for a plain `fn name(...)` prototype, `Variant::View` for `view fn name(...)`.
+    /// Other variants are not allowed in interface position.
+    pub variant: Variant,
     /// The function identifier, e.g., `foo` in `function foo(...) { ... }`.
     pub identifier: Identifier,
     /// The function's const parameters.
@@ -117,6 +121,7 @@ impl FunctionPrototype {
     #[allow(clippy::too_many_arguments)]
     pub fn new(
         annotations: Vec<Annotation>,
+        variant: Variant,
         identifier: Identifier,
         const_parameters: Vec<ConstParameter>,
         input: Vec<Input>,
@@ -130,7 +135,7 @@ impl FunctionPrototype {
             _ => Type::Tuple(TupleType::new(output.iter().map(|o| o.type_.clone()).collect())),
         };
 
-        Self { annotations, identifier, const_parameters, input, output, output_type, span, id }
+        Self { annotations, variant, identifier, const_parameters, input, output, output_type, span, id }
     }
 }
 
@@ -153,7 +158,10 @@ impl fmt::Display for FunctionPrototype {
         for annotation in &self.annotations {
             writeln!(f, "{annotation}")?;
         }
-        write!(f, "fn {}", self.identifier)?;
+        match self.variant {
+            Variant::View => write!(f, "view fn {}", self.identifier)?,
+            _ => write!(f, "fn {}", self.identifier)?,
+        }
         if !self.const_parameters.is_empty() {
             write!(f, "::[{}]", self.const_parameters.iter().format(", "))?;
         }