Struct GenericSdk 

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

The SDK provides convenience methods and constructors for provers.

The SDK is stateful to cache results of computations that depend only on the App VM config and aggregation config. The SDK will not cache any state that depends on the program executable.

Some commonly used methods are:

• execute
• prove
• verify_proof

Implementations

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

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 halo2_config(&self) -> &Halo2Config

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

pub fn app_vm_builder(&self) -> &VB

pub fn native_builder(&self) -> &NativeBuilder

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

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

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

pub fn agg_config_mut(&mut self) -> &mut AggregationConfig

pub fn agg_tree_config_mut(&mut self) -> &mut AggregationTreeConfig

pub fn halo2_config_mut(&mut self) -> &mut Halo2Config

pub fn halo2_params_reader_mut(&mut self) -> &mut CacheHalo2ParamsReader

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

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

pub fn with_app_config(self, val: AppConfig<VB::VmConfig>) -> Self

pub fn with_agg_config(self, val: AggregationConfig) -> Self

pub fn with_agg_tree_config(self, val: AggregationTreeConfig) -> Self

pub fn with_halo2_config(self, val: Halo2Config) -> Self

pub fn with_halo2_params_reader(self, val: CacheHalo2ParamsReader) -> Self

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

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

pub fn standard() -> 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, including the order of the moduli and elliptic curve parameters of the respective extensions: The app_vm_config field of your openvm.toml must exactly match the following:

[app_vm_config.rv32i]
[app_vm_config.rv32m]
[app_vm_config.io]

[app_vm_config.keccak]
[app_vm_config.sha256]
[app_vm_config.bigint]

[app_vm_config.modular]
supported_moduli = [
    # bn254 (alt bn128)
    "21888242871839275222246405745257275088696311157297823662689037894645226208583", # coordinate field
    "21888242871839275222246405745257275088548364400416034343698204186575808495617", # scalar field
    # secp256k1 (k256)
    "115792089237316195423570985008687907853269984665640564039457584007908834671663", # coordinate field
    "115792089237316195423570985008687907852837564279074904382605163141518161494337", # scalar field
    # secp256r1 (p256)
    "115792089210356248762697446949407573530086143415290314195533631308867097853951", # coordinate
    "115792089210356248762697446949407573529996955224135760342422259061068512044369", # scalar
    # bls12_381
    "4002409555221667393417789825735904156556882819939007885332058136124031650490837864442687629129015664037894272559787", # coordinate field
    "52435875175126190479447740508185965837690552500527637822603658699938581184513",                                       # scalar field
]

[app_vm_config.fp2]
supported_moduli = [
    [
        "Bn254Fp2",
        # bn254 (alt bn128)
        "21888242871839275222246405745257275088696311157297823662689037894645226208583",
    ],
    # Bls12_381
    [
        "Bls12_381Fp2",
        "4002409555221667393417789825735904156556882819939007885332058136124031650490837864442687629129015664037894272559787",
    ],
]

# bn254 (alt bn128)
[[app_vm_config.ecc.supported_curves]]
struct_name = "Bn254G1Affine"
modulus = "21888242871839275222246405745257275088696311157297823662689037894645226208583"
scalar = "21888242871839275222246405745257275088548364400416034343698204186575808495617"
a = "0"
b = "3"

# secp256k1 (k256)
[[app_vm_config.ecc.supported_curves]]
struct_name = "Secp256k1Point"
modulus = "115792089237316195423570985008687907853269984665640564039457584007908834671663"
scalar = "115792089237316195423570985008687907852837564279074904382605163141518161494337"
a = "0"
b = "7"

# secp256r1 (p256)
[[app_vm_config.ecc.supported_curves]]
struct_name = "P256Point"
modulus = "115792089210356248762697446949407573530086143415290314195533631308867097853951"
scalar = "115792089210356248762697446949407573529996955224135760342422259061068512044369"
a = "115792089210356248762697446949407573530086143415290314195533631308867097853948"
b = "41058363725152142129326129780047268409114441015993725554835256314039467401291"

# bls12_381
[[app_vm_config.ecc.supported_curves]]
struct_name = "Bls12_381G1Affine"
modulus = "4002409555221667393417789825735904156556882819939007885332058136124031650490837864442687629129015664037894272559787"
scalar = "52435875175126190479447740508185965837690552500527637822603658699938581184513"
a = "0"
b = "4"

[app_vm_config.pairing]
supported_curves = ["Bn254", "Bls12_381"]

pub fn riscv32() -> Self

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

Note: To use this configuration, your openvm.toml must exactly match the following:

[app_vm_config.rv32i]
[app_vm_config.rv32m]
[app_vm_config.io]

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

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

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

where VB: Default, NativeBuilder: 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>, ) -> Result<Self, SdkError>

where VB: Default, NativeBuilder: Default,

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

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 set_transpiler(&mut self, transpiler: Transpiler<F>)

pub fn with_transpiler(self, transpiler: Transpiler<F>) -> Self

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

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

where E: StarkFriEngine<SC = SC>, VB: VmBuilder<E> + Clone, <VB::VmConfig as VmExecutionConfig<F>>::Executor: Executor<F> + MeteredExecutor<F> + PreflightExecutor<F, VB::RecordArena>, NativeBuilder: VmBuilder<E, VmConfig = NativeConfig> + Clone, <NativeConfig as VmExecutionConfig<F>>::Executor: PreflightExecutor<F, <NativeBuilder as VmBuilder<E>>::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, ) -> Result<(VmStarkProof<SC>, AppExecutionCommit), SdkError>

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

The returned STARK proof is not intended for EVM verification. For EVM verification, use the prove_evm method, which requires the "evm-prove" feature to be enabled.

For convenience, this function also returns the AppExecutionCommit, which is a full commitment to the App VM config and the App VmExe. It does not depend on the inputs. It can be generated separately from the proof by creating a prover and calling app_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, ) -> Result<EvmProof, SdkError>

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

Constructs a new StarkProver instance for the given executable. This function will generate the AppProvingKey and AggProvingKey if they do not already exist.

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

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 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 set_app_pk( &self, app_pk: AppProvingKey<VB::VmConfig>, ) -> Result<(), AppProvingKey<VB::VmConfig>>

Sets the app proving key. Returns Ok(()) if app keygen has not been called and Err(app_pk) if keygen has already been called.

pub fn with_app_pk(self, app_pk: AppProvingKey<VB::VmConfig>) -> Self

See set_app_pk. This should only be used in a constructor, and panics if app keygen has already been called.

pub fn agg_keygen(&self) -> Result<(AggProvingKey, AggVerifyingKey), SdkError>

Generates the proving keys necessary for STARK aggregation. Generates the proving keys once and caches them. Future calls will return the cached key. This function does not include app_keygen, which is specific to the App VM config. The proving keys generated in this step are independent of the App VM config.

Panics

This function will panic if the keygen fails.

pub fn agg_pk(&self) -> &AggProvingKey

pub fn set_agg_pk(&self, agg_pk: AggProvingKey) -> Result<(), AggProvingKey>

Sets the aggregation proving keys. Returns Ok(()) if agg keygen has not been called and Err(agg_pk) if keygen has already been called.

pub fn with_agg_pk(self, agg_pk: AggProvingKey) -> Self

See set_agg_pk. This should only be used in a constructor, and panics if app keygen has already been called.

pub fn agg_pk_and_dummy_internal_proof(&self) -> (&AggProvingKey, &Proof<SC>)

pub fn generate_root_verifier_asm(&self) -> String

pub fn halo2_keygen(&self) -> Halo2ProvingKey

pub fn halo2_pk(&self) -> &Halo2ProvingKey

pub fn set_halo2_pk( &self, halo2_pk: Halo2ProvingKey, ) -> Result<(), Halo2ProvingKey>

Sets the halo2 proving keys. Returns Ok(()) if halo2 keygen has not been called and Err(halo2_pk) if keygen has already been called.

pub fn with_halo2_pk(self, halo2_pk: Halo2ProvingKey) -> Self

See set_halo2_pk. This should only be used in a constructor, and panics if halo2 keygen has already been called.

pub fn with_halo2_params_dir(self, params_dir: impl AsRef<Path>) -> Self

pub fn set_halo2_params_dir(&mut self, params_dir: impl AsRef<Path>)

pub fn verify_proof( agg_vk: &AggVerifyingKey, expected_app_commit: AppExecutionCommit, proof: &VmStarkProof<SC>, ) -> 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>

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

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