Struct GenericSdk 

pub struct GenericSdk<E, VB>
where
    E: StarkEngine<SC = SC>,
    VB: VmBuilder<E>,
    VB::VmConfig: VmExecutionConfig<F>,
{ /* private fields */ }

The SDK provides convenience methods and constructors for provers.

A built SDK is an immutable proving environment: user-supplied config, params, and pre-generated keys are fixed after construction. Use builder for advanced initialization, or new / new_without_transpiler for the common config-driven paths.

Internally, the SDK lazily caches proving state that depends only on the app VM config, aggregation config, root params, and optional pre-generated keys. It does not cache any state that depends on the program executable.

Some commonly used methods are:

• execute
• prove
• verify_proof

Implementations

impl<E, VB> GenericSdk<E, VB>

where E: StarkEngine<SC = SC>, VB: VmBuilder<E>, VB::VmConfig: VmExecutionConfig<F>,

pub fn builder() -> GenericSdkBuilder<E, VB>

Returns a builder for constructing an immutable GenericSdk.

pub fn from_cached_proving_key( cached_pk: SdkCachedProvingKey<VB::VmConfig>, ) -> Result<Self, SdkError>

where VB: Default, VB::VmConfig: TranspilerConfig<F>,

Builds an SDK from cached proving keys without deferral prover reconstruction.

This generic constructor requires the cached key to have no deferral proving keys. Use from_deferral_cached_proving_key for SdkVmConfig caches that include supported deferral provers.

impl<E, VB> GenericSdk<E, VB>

where E: StarkEngine<SC = SC>, VB: VmBuilder<E, VmConfig = SdkVmConfig>,

pub fn from_deferral_cached_proving_key( cached_pk: SdkCachedProvingKey<SdkVmConfig>, ) -> Result<Self, SdkError>

where VB: Default,

Builds an SDK from proving keys returned by GenericSdk::cached_proving_key.

If the cached key includes deferral proving keys, the SDK reads the app VM deferral config to initialize the corresponding supported deferral provers. Custom deferral circuit provers must be manually created and supplied through GenericSdkBuilder::deferral_agg_prover.

impl<E, VB> GenericSdk<E, VB>

where E: StarkEngine<SC = SC>, VB: VmBuilder<E>, VB::VmConfig: VmExecutionConfig<F>,

pub fn app_config(&self) -> &AppConfig<VB::VmConfig>

pub fn agg_config(&self) -> &AggregationConfig

pub fn agg_tree_config(&self) -> &AggregationTreeConfig

pub fn root_params(&self) -> &SystemParams

pub fn halo2_shape(&self) -> &StaticVerifierShape

pub fn halo2_config(&self) -> &Halo2Config

pub fn app_vm_builder(&self) -> &VB

pub fn executor(&self) -> &VmExecutor<F, VB::VmConfig>

The executor may be used to construct different types of interpreters, given the program, for more specific execution purposes. By default, it is recommended to use the execute method.

pub fn halo2_params_reader(&self) -> &CacheHalo2ParamsReader

impl<E, VB> GenericSdk<E, VB>

where E: StarkEngine<SC = SC>, VB: VmBuilder<E, VmConfig = SdkVmConfig> + Clone + Default,

pub fn standard( app_params: SystemParams, agg_params: AggregationSystemParams, ) -> Self

Creates SDK with a standard configuration that includes a set of default VM extensions loaded.

Note: To use this configuration, your openvm.toml must match SdkVmConfig::standard, including the order of the moduli and elliptic curve parameters of the respective extensions. See the openvm-sdk-config crate documentation for the corresponding TOML.

pub fn riscv32( app_params: SystemParams, agg_params: AggregationSystemParams, ) -> Self

Creates SDK with a configuration with RISC-V RV32IM and IO VM extensions loaded.

Note: To use this configuration, your openvm.toml must match SdkVmConfig::riscv32. See the openvm-sdk-config crate documentation for the corresponding TOML.

impl<E, VB> GenericSdk<E, VB>

where E: StarkEngine<SC = SC>, VB: VmBuilder<E>,

pub fn new( app_config: AppConfig<VB::VmConfig>, agg_params: AggregationSystemParams, ) -> Result<Self, SdkError>

where VB: Default, VB::VmConfig: TranspilerConfig<F>,

Creates SDK custom to the given AppConfig, with a RISC-V transpiler.

pub fn new_without_transpiler( app_config: AppConfig<VB::VmConfig>, agg_params: AggregationSystemParams, ) -> Result<Self, SdkError>

where VB: Default,

Creates an SDK custom to the given AppConfig without configuring a transpiler.

Note: This function does not set the transpiler, which must be done separately to support RISC-V ELFs.

pub fn def_hook_cached_commit(&self) -> Option<Digest>

Returns the def_hook_prover cached commit.

pub fn def_hook_commit(&self) -> Option<Digest>

Returns the deferral hook commit derived from the deferral aggregation path.

pub fn deferral_agg_prover(&self) -> Option<Arc<DeferralAggProver>>

Returns the deferral aggregation prover when this SDK can prove non-empty deferral inputs.

pub fn deferral_circuit_cached_commits( &self, def_idx: usize, ) -> Result<Vec<CommitBytes>, SdkError>

Derives the cached commits that the deferral circuit at def_idx expects callers to fold into its input commit.

pub fn cached_proving_key( &self, ) -> Result<SdkCachedProvingKey<VB::VmConfig>, SdkError>

Returns serde-serializable proving keys for this SDK.

This errors if app_pk or agg_pk have not already been generated or seeded into the SDK. Optional keys are returned only if they are already cached or were seeded into the SDK.

Halo2 proving keys are intentionally excluded; use write_halo2_pk_to_file and read_halo2_pk_from_file for those.

pub fn build<P: AsRef<Path>>( &self, guest_opts: GuestOptions, pkg_dir: P, target_filter: &Option<TargetFilter>, init_file_name: Option<&str>, ) -> Result<Elf, SdkError>

Builds the guest package located at pkg_dir. This function requires that the build target is unique and errors otherwise. Returns the built ELF file decoded in the Elf type.

pub fn transpiler(&self) -> Result<&Transpiler<F>, SdkError>

Transpiler for transpiling RISC-V ELF to OpenVM executable.

pub fn convert_to_exe( &self, executable: impl Into<ExecutableFormat>, ) -> Result<Arc<VmExe<F>>, SdkError>

Normalizes an ELF or executable handle into a shared VmExe.

impl<E, VB> GenericSdk<E, VB>

where E: StarkEngine<SC = SC>, VB: VmBuilder<E> + Clone, <VB::VmConfig as VmExecutionConfig<F>>::Executor: Executor<F> + MeteredExecutor<F> + PreflightExecutor<F, VB::RecordArena>,

pub fn execute( &self, app_exe: impl Into<ExecutableFormat>, inputs: StdIn, ) -> Result<Vec<u8>, SdkError>

Returns the user public values as field elements.

pub fn execute_metered( &self, app_exe: impl Into<ExecutableFormat>, inputs: StdIn, ) -> Result<(Vec<u8>, Vec<Segment>), SdkError>

Executes with segmentation for proof generation. Returns both user public values and segments with instruction counts and trace heights.

pub fn execute_metered_cost( &self, app_exe: impl Into<ExecutableFormat>, inputs: StdIn, ) -> Result<(Vec<u8>, (u64, u64)), SdkError>

Executes with cost metering to measure computational cost in trace cells. Returns both user public values, and cost along with instruction count.

pub fn prove( &self, app_exe: impl Into<ExecutableFormat>, inputs: StdIn, def_inputs: &[DeferralInput], ) -> Result<(VmStarkProof, VerificationBaseline), SdkError>

Generates a single aggregate STARK proof of the full program execution of the given app_exe with program inputs inputs.\

For convenience, this function also returns the VerificationBaseline, which is a full commitment to the App VmExe and aggregation verifiers. It does not depend on the inputs. It can be generated separately from the proof by creating a prover and calling app_vm_commit.

If STARK aggregation is not needed and a proof whose size may grow linearly with the length of the program runtime is desired, create an app_prover and call app_prover.prove(inputs).

pub fn prove_evm( &self, app_exe: impl Into<ExecutableFormat>, inputs: StdIn, def_inputs: &[DeferralInput], ) -> Result<EvmProof, SdkError>

Generates an EVM-verifiable proof for the given executable and inputs.

pub fn app_prover( &self, exe: impl Into<ExecutableFormat>, ) -> Result<AppProver<E, VB>, SdkError>

This constructor is for generating app proofs that do not require a single aggregate STARK proof of the full program execution. For a single STARK proof, use the prove method instead.

Creates an app prover instance specific to the provided exe. This function will generate the AppProvingKey if it doesn’t already exist and use it to construct the AppProver.

pub fn prover( &self, app_exe: impl Into<ExecutableFormat>, ) -> Result<StarkProver<E, VB>, SdkError>

Constructs a new StarkProver instance for the given executable. This function will generate the AppProvingKey if it does not already exist.

pub fn evm_prover_without_halo2( &self, app_exe: impl Into<ExecutableFormat>, ) -> Result<EvmProver<E, VB>, SdkError>

Constructs an EvmProver for the given executable with only the root prover, generating prerequisite keys, lazily

pub fn evm_prover( &self, app_exe: impl Into<ExecutableFormat>, ) -> Result<EvmProver<E, VB>, SdkError>

Constructs an EvmProver for the given executable, generating prerequisite keys lazily.

pub fn agg_prover(&self) -> Arc<AggProver>

Returns the cached aggregation prover, generating it on first use if needed.

pub fn root_prover(&self) -> Arc<RootProver>

Returns the cached root prover, generating it on first use if needed.

pub fn halo2_prover(&self) -> Halo2Prover

Returns the cached Halo2 prover, generating it on first use if needed.

pub fn app_keygen(&self) -> (AppProvingKey<VB::VmConfig>, AppVerifyingKey)

Generates the app proving key once and caches it. Future calls will return the cached key.

Panics

This function will panic if the app keygen fails.

pub fn app_pk(&self) -> &AppProvingKey<VB::VmConfig>

Generates the app proving key once and caches it. Future calls will return the cached key.

Panics

This function will panic if the app keygen fails.

pub fn app_vk(&self) -> AppVerifyingKey

Returns the app verifying key derived from the cached app proving key.

pub fn agg_keygen(&self) -> (AggProvingKey, MultiStarkVerifyingKey<SC>)

Generates or retrieves the aggregation proving and verifying keys as a pair.

pub fn agg_prefix_pk(&self) -> AggPrefixProvingKey

Generates or retrieves the aggregation prefix proving key without the internal-recursive key.

pub fn agg_pk(&self) -> AggProvingKey

Generates or retrieves the full aggregation proving key.

pub fn agg_vk(&self) -> Arc<MultiStarkVerifyingKey<SC>>

Returns the aggregation verifying key for the recursive aggregation layer.

pub fn root_pk(&self) -> RootProvingKey

Generates or retrieves the root proving key and recorded trace heights.

pub fn halo2_pk(&self) -> Halo2ProvingKey

Generates the Halo2 (static verifier + wrapper) proving key once and caches it.

The flow:

1. Get the root VK and internal recursive VK cached commit
2. Generate a dummy root proof via the EVM prover pipeline
3. Keygen the static verifier circuit
4. Generate a dummy snark from the verifier
5. Keygen the wrapper circuit (auto-tuned or fixed k)

pub fn app_commit( &self, app_exe: impl Into<ExecutableFormat>, ) -> Result<AppExecutionCommit, SdkError>

Generates the AppExecutionCommit for the given executable.

This function will generate the app_pk if it does not already exist.

pub fn verify_proof( agg_vk: MultiStarkVerifyingKey<SC>, baseline: VerificationBaseline, proof: &VmStarkProof, ) -> Result<(), SdkError>

Verifies aggregate STARK proof of VM execution.

Note: This function does not have any reliance on self and does not depend on the app config set in the Sdk.

pub fn generate_halo2_verifier_solidity( &self, ) -> Result<EvmHalo2Verifier, SdkError>

Generates Solidity verifier artifacts for the cached Halo2 proving key.

pub fn generate_halo2_verifier_solidity_with_version_name( &self, version_name: &str, ) -> Result<EvmHalo2Verifier, SdkError>

Generates Solidity verifier artifacts under src/{version_name} in the solc source map.

Solidity embeds source metadata in bytecode, so version_name should match the directory where the generated verifier contracts will be written.

pub fn verify_evm_halo2_proof( openvm_verifier: &EvmHalo2Verifier, evm_proof: EvmProof, expected_app_commit: Option<AppExecutionCommit>, ) -> Result<u64, SdkError>

Uses the verify(..) interface of the OpenVmHalo2Verifier contract.

Requires the evm-verify feature. Internally deploys the verifier bytecode in a local EVM and executes the verification call. If expected_app_commit is provided, it will check the proof’s app_commit against it.