diff --git a/taiga_halo2/Cargo.toml b/taiga_halo2/Cargo.toml
index 1aafa651..73ec8d8b 100644
--- a/taiga_halo2/Cargo.toml
+++ b/taiga_halo2/Cargo.toml
@@ -44,9 +44,11 @@ harness = false
 
 [[example]]
 name = "tx_examples"
+required-features = ["examples"]
 
 [features]
 default = []
 nif = ["dep:rustler", "borsh", "pasta_curves/repr-erlang"]
 serde = ["dep:serde", "pasta_curves/serde"]
 borsh = ["dep:borsh"]
+examples = []
diff --git a/taiga_halo2/params/params_15 b/taiga_halo2/params/params_15
new file mode 100644
index 00000000..0c620297
Binary files /dev/null and b/taiga_halo2/params/params_15 differ
diff --git a/taiga_halo2/src/circuit/mod.rs b/taiga_halo2/src/circuit/mod.rs
index ddeab568..bf45e402 100644
--- a/taiga_halo2/src/circuit/mod.rs
+++ b/taiga_halo2/src/circuit/mod.rs
@@ -9,6 +9,5 @@ pub mod blake2s;
 pub mod curve;
 pub mod hash_to_curve;
 pub mod note_encryption_circuit;
-pub mod schnorr_signature;
 mod vamp_ir_utils;
 pub mod vp_examples;
diff --git a/taiga_halo2/src/circuit/schnorr_signature.rs b/taiga_halo2/src/circuit/schnorr_signature.rs
deleted file mode 100644
index 05592b49..00000000
--- a/taiga_halo2/src/circuit/schnorr_signature.rs
+++ /dev/null
@@ -1,404 +0,0 @@
-use halo2_proofs::{
-    circuit::{floor_planner, Layouter, Value},
-    plonk::{self, Advice, Column, Instance as InstanceColumn},
-};
-use pasta_curves::arithmetic::CurveAffine;
-use pasta_curves::group::Curve;
-use pasta_curves::group::Group;
-use pasta_curves::pallas;
-
-use crate::{
-    circuit::gadgets::{
-        add::{AddChip, AddConfig},
-        assign_free_advice, assign_free_instance,
-        mul::{MulChip, MulConfig},
-        poseidon_hash::poseidon_hash_gadget,
-        sub::{SubChip, SubConfig},
-    },
-    constant::{
-        NoteCommitmentDomain, NoteCommitmentHashDomain, TaigaFixedBases, TaigaFixedBasesFull,
-    },
-};
-use halo2_gadgets::{
-    ecc::{
-        chip::{EccChip, EccConfig},
-        FixedPoint, NonIdentityPoint, ScalarFixed, ScalarVar,
-    },
-    poseidon::{primitives as poseidon, Pow5Chip as PoseidonChip, Pow5Config as PoseidonConfig},
-    sinsemilla::chip::{SinsemillaChip, SinsemillaConfig},
-    utilities::lookup_range_check::LookupRangeCheckConfig,
-};
-
-#[derive(Clone, Debug)]
-pub struct SchnorrConfig {
-    primary: Column<InstanceColumn>,
-    advices: [Column<Advice>; 10],
-    add_config: AddConfig,
-    sub_config: SubConfig,
-    mul_config: MulConfig,
-    ecc_config: EccConfig<TaigaFixedBases>, // TODO: Maybe replace
-    poseidon_config: PoseidonConfig<pallas::Base, 3, 2>,
-    sinsemilla_config:
-        SinsemillaConfig<NoteCommitmentHashDomain, NoteCommitmentDomain, TaigaFixedBases>,
-}
-
-impl SchnorrConfig {
-    pub(super) fn add_chip(&self) -> AddChip<pallas::Base> {
-        AddChip::construct(self.add_config.clone(), ())
-    }
-
-    pub(super) fn sub_chip(&self) -> SubChip<pallas::Base> {
-        SubChip::construct(self.sub_config.clone(), ())
-    }
-
-    pub(super) fn mul_chip(&self) -> MulChip<pallas::Base> {
-        MulChip::construct(self.mul_config.clone())
-    }
-
-    pub(super) fn ecc_chip(&self) -> EccChip<TaigaFixedBases> {
-        EccChip::construct(self.ecc_config.clone())
-    }
-
-    pub(super) fn poseidon_chip(&self) -> PoseidonChip<pallas::Base, 3, 2> {
-        PoseidonChip::construct(self.poseidon_config.clone())
-    }
-}
-
-#[derive(Clone, Debug, Default)]
-pub struct SchnorrCircuit {
-    // public key
-    pk: pallas::Point,
-    // signature (r,s)
-    r: pallas::Point,
-    s: pallas::Scalar,
-}
-
-impl plonk::Circuit<pallas::Base> for SchnorrCircuit {
-    type Config = SchnorrConfig;
-    type FloorPlanner = floor_planner::V1;
-
-    fn without_witnesses(&self) -> Self {
-        SchnorrCircuit {
-            pk: pallas::Point::generator(),
-            r: pallas::Point::generator(),
-            s: pallas::Scalar::one(),
-        }
-    }
-
-    fn configure(meta: &mut plonk::ConstraintSystem<pallas::Base>) -> Self::Config {
-        let advices = [
-            meta.advice_column(),
-            meta.advice_column(),
-            meta.advice_column(),
-            meta.advice_column(),
-            meta.advice_column(),
-            meta.advice_column(),
-            meta.advice_column(),
-            meta.advice_column(),
-            meta.advice_column(),
-            meta.advice_column(),
-        ];
-
-        // Addition of two field elements.
-        let add_config = AddChip::configure(meta, [advices[0], advices[1]]);
-
-        // Substraction of two field elements.
-        let sub_config = SubChip::configure(meta, [advices[0], advices[1]]);
-
-        // Multiplication of two field elements.
-        let mul_config = MulChip::configure(meta, [advices[0], advices[1]]);
-
-        let lagrange_coeffs = [
-            meta.fixed_column(),
-            meta.fixed_column(),
-            meta.fixed_column(),
-            meta.fixed_column(),
-            meta.fixed_column(),
-            meta.fixed_column(),
-            meta.fixed_column(),
-            meta.fixed_column(),
-        ];
-        meta.enable_constant(lagrange_coeffs[0]);
-
-        let table_idx = meta.lookup_table_column();
-
-        let range_check = LookupRangeCheckConfig::configure(meta, advices[9], table_idx);
-
-        let lookup = (
-            table_idx,
-            meta.lookup_table_column(),
-            meta.lookup_table_column(),
-        );
-        let sinsemilla_config = SinsemillaChip::<
-            NoteCommitmentHashDomain,
-            NoteCommitmentDomain,
-            TaigaFixedBases,
-        >::configure(
-            meta,
-            advices[..5].try_into().unwrap(),
-            advices[2],
-            lagrange_coeffs[0],
-            lookup,
-            range_check,
-        );
-
-        let ecc_config =
-            EccChip::<TaigaFixedBases>::configure(meta, advices, lagrange_coeffs, range_check);
-
-        // Instance column used for public inputs
-        let primary = meta.instance_column();
-        meta.enable_equality(primary);
-
-        // Permutation over all advice columns.
-        for advice in advices.iter() {
-            meta.enable_equality(*advice);
-        }
-
-        // Poseidon requires four advice columns, while ECC incomplete addition requires
-        // six, so we could choose to configure them in parallel. However, we only use a
-        // single Poseidon invocation, and we have the rows to accommodate it serially.
-        // Instead, we reduce the proof size by sharing fixed columns between the ECC and
-        // Poseidon chips.
-        let lagrange_coeffs = [
-            meta.fixed_column(),
-            meta.fixed_column(),
-            meta.fixed_column(),
-            meta.fixed_column(),
-            meta.fixed_column(),
-            meta.fixed_column(),
-            meta.fixed_column(),
-            meta.fixed_column(),
-        ];
-        let rc_a = lagrange_coeffs[2..5].try_into().unwrap();
-        let rc_b = lagrange_coeffs[5..8].try_into().unwrap();
-
-        // Also use the first Lagrange coefficient column for loading global constants.
-        // It's free real estate :)
-        meta.enable_constant(lagrange_coeffs[0]);
-
-        // Configuration for the Poseidon hash.
-        let poseidon_config = PoseidonChip::configure::<poseidon::P128Pow5T3>(
-            meta,
-            // We place the state columns after the partial_sbox column so that the
-            // pad-and-add region can be laid out more efficiently.
-            advices[0..3].try_into().unwrap(),
-            advices[4],
-            rc_a,
-            rc_b,
-        );
-
-        SchnorrConfig {
-            primary,
-            advices,
-            add_config,
-            sub_config,
-            mul_config,
-            ecc_config,
-            poseidon_config,
-            sinsemilla_config,
-        }
-    }
-
-    #[allow(non_snake_case)]
-    fn synthesize(
-        &self,
-        config: Self::Config,
-        mut layouter: impl Layouter<pallas::Base>,
-    ) -> Result<(), plonk::Error> {
-        SinsemillaChip::<NoteCommitmentHashDomain, NoteCommitmentDomain, TaigaFixedBases>::load(
-            config.sinsemilla_config,
-            &mut layouter,
-        )?;
-        // We implement the verification algorithm first
-        // and assume that the signature is given
-        // Construct an ECC chip
-        let ecc_chip = EccChip::construct(config.ecc_config);
-        // TODO: Message length (256bits) is bigger than the size of Fp (255bits)
-        // Obtain message: m
-        let m_cell = assign_free_instance(
-            layouter.namespace(|| "message instance"),
-            config.primary,
-            0,
-            config.advices[0],
-        )
-        .unwrap();
-        // Obtain the signature: (R,s)
-        let R = NonIdentityPoint::new(
-            ecc_chip.clone(),
-            layouter.namespace(|| "non-identity R"),
-            Value::known(self.r.to_affine()),
-        )?;
-        let s_scalar = ScalarFixed::new(
-            ecc_chip.clone(),
-            layouter.namespace(|| "s"),
-            Value::known(self.s),
-        )?;
-        // Obtain public key : P
-        let (px_cell, py_cell) = {
-            let p_coord = self.pk.to_affine().coordinates().unwrap();
-            let px_cell = assign_free_advice(
-                layouter.namespace(|| "px"),
-                config.advices[0],
-                Value::known(*p_coord.x()),
-            )?;
-            let py_cell = assign_free_advice(
-                layouter.namespace(|| "py"),
-                config.advices[1],
-                Value::known(*p_coord.y()),
-            )?;
-            (px_cell, py_cell)
-        };
-
-        // Verify: s*G = R + Hash(r||P||m)*P
-        // s*G
-        let generator =
-            FixedPoint::from_inner(ecc_chip.clone(), TaigaFixedBasesFull::NoteCommitmentR);
-        let (sG, _) = generator.mul(layouter.namespace(|| "s_scalar * generator"), &s_scalar)?;
-
-        // Hash(r||P||m)
-        let h_scalar = {
-            let rx_cell = R.inner().x();
-            let ry_cell = R.inner().y();
-            let zero_cell = assign_free_advice(
-                layouter.namespace(|| "zero"),
-                config.advices[0],
-                Value::known(pallas::Base::zero()),
-            )?;
-            let poseidon_message = [
-                rx_cell,
-                ry_cell,
-                px_cell,
-                py_cell,
-                m_cell,
-                zero_cell.clone(),
-                zero_cell.clone(),
-                zero_cell,
-            ];
-            let h = poseidon_hash_gadget::<8>(
-                config.poseidon_config,
-                layouter.namespace(|| "Poseidon_hash(r, P, m)"),
-                poseidon_message,
-            )?;
-
-            ScalarVar::from_base(
-                ecc_chip.clone(),
-                layouter.namespace(|| "ScalarVar from_base"),
-                &h,
-            )?
-        };
-
-        // Hash(r||P||m)*P
-        let (hP, _) = {
-            let P = NonIdentityPoint::new(
-                ecc_chip,
-                layouter.namespace(|| "non-identity P"),
-                Value::known(self.pk.to_affine()),
-            )?;
-            P.mul(layouter.namespace(|| "hP"), h_scalar)?
-        };
-
-        // R + Hash(r||P||m)*P
-        let rhs = R.add(layouter.namespace(|| "R + Hash(r||P||m)*P"), &hP)?;
-
-        sG.constrain_equal(layouter.namespace(|| "s*G = R + Hash(r||P||m)*P"), &rhs)?;
-        Ok(())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use halo2_proofs::{arithmetic::CurveAffine, dev::MockProver};
-
-    use rand::{rngs::OsRng, RngCore};
-
-    use super::SchnorrCircuit;
-
-    use crate::{
-        constant::NOTE_COMMIT_DOMAIN,
-        proof::Proof,
-        utils::{mod_r_p, poseidon_hash_n},
-    };
-    use halo2_proofs::{
-        plonk::{self},
-        poly::commitment::Params,
-    };
-    use pasta_curves::{group::Curve, pallas};
-    use std::time::Instant;
-
-    use std::{
-        collections::hash_map::DefaultHasher,
-        hash::{Hash, Hasher},
-    };
-
-    fn calculate_hash<T: Hash + ?Sized>(t: &T) -> u64 {
-        let mut s = DefaultHasher::new();
-        t.hash(&mut s);
-        s.finish()
-    }
-
-    #[test]
-    fn test_schnorr() {
-        let mut rng = OsRng;
-        const K: u32 = 13;
-        let generator = NOTE_COMMIT_DOMAIN.R();
-        // Message hash: m
-        let m = pallas::Base::from(calculate_hash(
-            "Every day you play with the light of the universe. Subtle visitor",
-        ));
-        // Private key: sk
-        let sk = pallas::Scalar::from(rng.next_u64());
-        // Public key: P = sk*G
-        let pk = generator * sk;
-        let pk_coord = pk.to_affine().coordinates().unwrap();
-        // Generate a random number: z
-        let z = pallas::Scalar::from(rng.next_u64());
-        // Calculate: R = z*G
-        let r = generator * z;
-        let r_coord = r.to_affine().coordinates().unwrap();
-        // Calculate: s = z + Hash(r||P||m)*sk
-        let h = mod_r_p(poseidon_hash_n::<8>([
-            *r_coord.x(),
-            *r_coord.y(),
-            *pk_coord.x(),
-            *pk_coord.y(),
-            m,
-            pallas::Base::zero(),
-            pallas::Base::zero(),
-            pallas::Base::zero(),
-        ]));
-        let s = z + h * sk;
-        // Signature = (r, s)
-        let circuit = SchnorrCircuit { pk, r, s };
-
-        let pub_instance_vec = vec![m];
-        assert_eq!(
-            MockProver::run(K, &circuit, vec![pub_instance_vec.clone()])
-                .unwrap()
-                .verify(),
-            Ok(())
-        );
-        let prover = MockProver::run(K, &circuit, vec![pub_instance_vec]).unwrap();
-        prover.assert_satisfied();
-
-        let time = Instant::now();
-        let params = Params::new(K);
-
-        let vk = plonk::keygen_vk(&params, &circuit).unwrap();
-        let pk = plonk::keygen_pk(&params, vk.clone(), &circuit).unwrap();
-        println!(
-            "key generation: \t{:?}ms",
-            (Instant::now() - time).as_millis()
-        );
-
-        let time = Instant::now();
-        let proof = Proof::create(&pk, &params, circuit, &[&[m]], &mut rng).unwrap();
-        println!("proof: \t\t\t{:?}ms", (Instant::now() - time).as_millis());
-
-        let time = Instant::now();
-        assert!(proof.verify(&vk, &params, &[&[m]]).is_ok());
-        println!(
-            "verification: \t\t{:?}ms",
-            (Instant::now() - time).as_millis()
-        );
-    }
-}
diff --git a/taiga_halo2/src/circuit/vp_circuit.rs b/taiga_halo2/src/circuit/vp_circuit.rs
index 715da4ad..f25ba3da 100644
--- a/taiga_halo2/src/circuit/vp_circuit.rs
+++ b/taiga_halo2/src/circuit/vp_circuit.rs
@@ -702,6 +702,7 @@ impl BasicValidityPredicateVariables {
     }
 }
 
+// Default Circuit trait implementation
 #[macro_export]
 macro_rules! vp_circuit_impl {
     ($name:ident) => {
@@ -734,7 +735,13 @@ macro_rules! vp_circuit_impl {
                 Ok(())
             }
         }
+    };
+}
 
+// Default ValidityPredicateVerifyingInfo trait implementation
+#[macro_export]
+macro_rules! vp_verifying_info_impl {
+    ($name:ident) => {
         impl ValidityPredicateVerifyingInfo for $name {
             fn get_verifying_info(&self) -> VPVerifyingInfo {
                 let mut rng = OsRng;
diff --git a/taiga_halo2/src/circuit/vp_examples.rs b/taiga_halo2/src/circuit/vp_examples.rs
index 036ec4e0..1b9dbaaa 100644
--- a/taiga_halo2/src/circuit/vp_examples.rs
+++ b/taiga_halo2/src/circuit/vp_examples.rs
@@ -3,34 +3,51 @@ use crate::{
         VPVerifyingInfo, ValidityPredicateCircuit, ValidityPredicateConfig,
         ValidityPredicatePublicInputs, ValidityPredicateVerifyingInfo,
     },
-    constant::{NUM_NOTE, SETUP_PARAMS_MAP},
+    constant::{NUM_NOTE, SETUP_PARAMS_MAP, VP_CIRCUIT_PARAMS_SIZE},
     note::{Note, RandomSeed},
     proof::Proof,
     vp_commitment::ValidityPredicateCommitment,
     vp_vk::ValidityPredicateVerifyingKey,
 };
-use halo2_proofs::plonk::{keygen_pk, keygen_vk};
+use halo2_proofs::plonk::{keygen_pk, keygen_vk, ProvingKey};
 use halo2_proofs::{
     circuit::{floor_planner, Layouter},
     plonk::{Circuit, ConstraintSystem, Error},
 };
 use lazy_static::lazy_static;
-use pasta_curves::pallas;
+use pasta_curves::{pallas, vesta};
 use rand::{rngs::OsRng, RngCore};
 #[cfg(feature = "nif")]
 use rustler::{Decoder, Encoder, Env, NifResult, NifStruct, Term};
 
+#[cfg(feature = "examples")]
 pub mod cascade_intent;
+#[cfg(feature = "examples")]
 mod field_addition;
+#[cfg(feature = "examples")]
 pub mod or_relation_intent;
+#[cfg(feature = "examples")]
 pub mod partial_fulfillment_intent;
+#[cfg(feature = "examples")]
 pub mod receiver_vp;
+#[cfg(feature = "examples")]
 pub mod signature_verification;
+#[cfg(feature = "examples")]
 pub mod token;
 
 lazy_static! {
-    pub static ref TRIVIAL_VP_VK: ValidityPredicateVerifyingKey =
-        TrivialValidityPredicateCircuit::default().get_vp_vk();
+    pub static ref TRIVIAL_VP_VK: ValidityPredicateVerifyingKey = {
+        let params = SETUP_PARAMS_MAP.get(&VP_CIRCUIT_PARAMS_SIZE).unwrap();
+        let empty_circuit = TrivialValidityPredicateCircuit::default();
+        let vk = keygen_vk(params, &empty_circuit).expect("keygen_vk should not fail");
+        ValidityPredicateVerifyingKey::from_vk(vk)
+    };
+    pub static ref TRIVIAL_VP_PK: ProvingKey<vesta::Affine> = {
+        let params = SETUP_PARAMS_MAP.get(&VP_CIRCUIT_PARAMS_SIZE).unwrap();
+        let empty_circuit = TrivialValidityPredicateCircuit::default();
+        keygen_pk(params, TRIVIAL_VP_VK.get_vk().unwrap(), &empty_circuit)
+            .expect("keygen_pk should not fail")
+    };
     pub static ref COMPRESSED_TRIVIAL_VP_VK: pallas::Base = TRIVIAL_VP_VK.get_compressed();
 }
 
@@ -131,6 +148,31 @@ impl ValidityPredicateCircuit for TrivialValidityPredicateCircuit {
 
 vp_circuit_impl!(TrivialValidityPredicateCircuit);
 
+impl ValidityPredicateVerifyingInfo for TrivialValidityPredicateCircuit {
+    fn get_verifying_info(&self) -> VPVerifyingInfo {
+        let mut rng = OsRng;
+        let params = SETUP_PARAMS_MAP.get(&15).unwrap();
+        let public_inputs = self.get_public_inputs(&mut rng);
+        let proof = Proof::create(
+            &TRIVIAL_VP_PK,
+            params,
+            self.clone(),
+            &[public_inputs.inner()],
+            &mut rng,
+        )
+        .unwrap();
+        VPVerifyingInfo {
+            vk: TRIVIAL_VP_PK.get_vk().clone(),
+            proof,
+            public_inputs,
+        }
+    }
+
+    fn get_vp_vk(&self) -> ValidityPredicateVerifyingKey {
+        TRIVIAL_VP_VK.clone()
+    }
+}
+
 #[cfg(test)]
 pub mod tests {
     use super::TrivialValidityPredicateCircuit;
diff --git a/taiga_halo2/src/circuit/vp_examples/cascade_intent.rs b/taiga_halo2/src/circuit/vp_examples/cascade_intent.rs
index 9eb45a46..6c6fa9d0 100644
--- a/taiga_halo2/src/circuit/vp_examples/cascade_intent.rs
+++ b/taiga_halo2/src/circuit/vp_examples/cascade_intent.rs
@@ -145,6 +145,7 @@ impl ValidityPredicateCircuit for CascadeIntentValidityPredicateCircuit {
 }
 
 vp_circuit_impl!(CascadeIntentValidityPredicateCircuit);
+vp_verifying_info_impl!(CascadeIntentValidityPredicateCircuit);
 
 pub fn create_intent_note<R: RngCore>(
     mut rng: R,
diff --git a/taiga_halo2/src/circuit/vp_examples/field_addition.rs b/taiga_halo2/src/circuit/vp_examples/field_addition.rs
index 99805ae0..d021cfed 100644
--- a/taiga_halo2/src/circuit/vp_examples/field_addition.rs
+++ b/taiga_halo2/src/circuit/vp_examples/field_addition.rs
@@ -105,6 +105,7 @@ impl ValidityPredicateCircuit for FieldAdditionValidityPredicateCircuit {
 }
 
 vp_circuit_impl!(FieldAdditionValidityPredicateCircuit);
+vp_verifying_info_impl!(FieldAdditionValidityPredicateCircuit);
 
 #[test]
 fn test_halo2_addition_vp_circuit() {
diff --git a/taiga_halo2/src/circuit/vp_examples/or_relation_intent.rs b/taiga_halo2/src/circuit/vp_examples/or_relation_intent.rs
index 495ee56c..4c7bbd5b 100644
--- a/taiga_halo2/src/circuit/vp_examples/or_relation_intent.rs
+++ b/taiga_halo2/src/circuit/vp_examples/or_relation_intent.rs
@@ -283,6 +283,7 @@ impl ValidityPredicateCircuit for OrRelationIntentValidityPredicateCircuit {
 }
 
 vp_circuit_impl!(OrRelationIntentValidityPredicateCircuit);
+vp_verifying_info_impl!(OrRelationIntentValidityPredicateCircuit);
 
 pub fn create_intent_note<R: RngCore>(
     mut rng: R,
diff --git a/taiga_halo2/src/circuit/vp_examples/partial_fulfillment_intent.rs b/taiga_halo2/src/circuit/vp_examples/partial_fulfillment_intent.rs
index 9b37a53c..dcff24a3 100644
--- a/taiga_halo2/src/circuit/vp_examples/partial_fulfillment_intent.rs
+++ b/taiga_halo2/src/circuit/vp_examples/partial_fulfillment_intent.rs
@@ -451,6 +451,7 @@ impl ValidityPredicateCircuit for PartialFulfillmentIntentValidityPredicateCircu
 }
 
 vp_circuit_impl!(PartialFulfillmentIntentValidityPredicateCircuit);
+vp_verifying_info_impl!(PartialFulfillmentIntentValidityPredicateCircuit);
 
 pub fn create_intent_note<R: RngCore>(
     mut rng: R,
diff --git a/taiga_halo2/src/circuit/vp_examples/receiver_vp.rs b/taiga_halo2/src/circuit/vp_examples/receiver_vp.rs
index 3030e008..7c5afd1a 100644
--- a/taiga_halo2/src/circuit/vp_examples/receiver_vp.rs
+++ b/taiga_halo2/src/circuit/vp_examples/receiver_vp.rs
@@ -280,6 +280,7 @@ impl ValidityPredicateCircuit for ReceiverValidityPredicateCircuit {
 }
 
 vp_circuit_impl!(ReceiverValidityPredicateCircuit);
+vp_verifying_info_impl!(ReceiverValidityPredicateCircuit);
 
 #[test]
 fn test_halo2_receiver_vp_circuit() {
diff --git a/taiga_halo2/src/circuit/vp_examples/signature_verification.rs b/taiga_halo2/src/circuit/vp_examples/signature_verification.rs
index a1c17f96..0677cc77 100644
--- a/taiga_halo2/src/circuit/vp_examples/signature_verification.rs
+++ b/taiga_halo2/src/circuit/vp_examples/signature_verification.rs
@@ -287,6 +287,7 @@ impl ValidityPredicateCircuit for SignatureVerificationValidityPredicateCircuit
 }
 
 vp_circuit_impl!(SignatureVerificationValidityPredicateCircuit);
+vp_verifying_info_impl!(SignatureVerificationValidityPredicateCircuit);
 
 #[test]
 fn test_halo2_sig_verification_vp_circuit() {
diff --git a/taiga_halo2/src/circuit/vp_examples/token.rs b/taiga_halo2/src/circuit/vp_examples/token.rs
index 514ab1d9..a28bd8ec 100644
--- a/taiga_halo2/src/circuit/vp_examples/token.rs
+++ b/taiga_halo2/src/circuit/vp_examples/token.rs
@@ -313,6 +313,7 @@ impl ValidityPredicateCircuit for TokenValidityPredicateCircuit {
 }
 
 vp_circuit_impl!(TokenValidityPredicateCircuit);
+vp_verifying_info_impl!(TokenValidityPredicateCircuit);
 
 impl TokenAuthorization {
     pub fn new(pk: pallas::Point, vk: pallas::Base) -> Self {
diff --git a/taiga_halo2/src/constant.rs b/taiga_halo2/src/constant.rs
index 1b8280d9..0151e592 100644
--- a/taiga_halo2/src/constant.rs
+++ b/taiga_halo2/src/constant.rs
@@ -119,11 +119,12 @@ pub const VP_CIRCUIT_PARAMS_SIZE: u32 = PARAMS_SIZE;
 lazy_static! {
     pub static ref SETUP_PARAMS_MAP: HashMap<u32, Params<vesta::Affine>> = {
         let mut m = HashMap::new();
-        #[allow(clippy::single_element_loop)]
-        for circuit_size in [PARAMS_SIZE] {
-            let params = Params::new(circuit_size);
-            m.insert(circuit_size, params);
-        }
+        let params_15 = {
+            let bytes = include_bytes!("../params/params_15");
+            Params::<vesta::Affine>::read(&mut &bytes[..]).unwrap()
+        };
+
+        m.insert(PARAMS_SIZE, params_15);
         m
     };
 }
@@ -6088,6 +6089,8 @@ impl FixedPoint<pallas::Affine> for Short {
     }
 }
 
+pub const MAX_DYNAMIC_VP_NUM: usize = 2;
+
 #[ignore]
 #[test]
 fn r_u_z_generate() {
@@ -6113,4 +6116,51 @@ fn r_u_z_generate() {
     println!("]");
 }
 
-pub const MAX_DYNAMIC_VP_NUM: usize = 2;
+#[ignore]
+#[test]
+fn export_params() {
+    use std::io::Write;
+
+    let params: Params<vesta::Affine> = Params::new(PARAMS_SIZE);
+    let mut bytes = vec![];
+    params.write(&mut bytes).unwrap();
+    let mut file = std::fs::File::create("./params/params_15")
+        .unwrap_or_else(|err| panic!("cannot create params_15 with {}", err));
+    file.write_all(&bytes).unwrap();
+}
+
+// It takes 4 seconds to generate one proving key.
+// It may be fine to generate the key once when compiling.
+// Consider loading the key from file when the keys are stablized.
+// #[ignore]
+// #[test]
+// fn export_action_proving_key() {
+//     use std::io::Write;
+
+//     let params = SETUP_PARAMS_MAP.get(&ACTION_CIRCUIT_PARAMS_SIZE).unwrap();
+//     let empty_circuit: ActionCircuit = Default::default();
+//     let vk = keygen_vk(params, &empty_circuit).expect("keygen_vk should not fail");
+//     let pk = keygen_pk(params, vk, &empty_circuit).expect("keygen_pk should not fail");
+//     let mut bytes = vec![];
+//     pk.write(&mut bytes).unwrap();
+//     let mut file = std::fs::File::create("./params/action_proving_key")
+//         .unwrap_or_else(|err| panic!("cannot create action_proving_key with {}", err));
+//     file.write_all(&bytes).unwrap();
+// }
+
+// #[ignore]
+// #[test]
+// fn export_trivial_vp_proving_key() {
+//     use crate::circuit::vp_examples::TrivialValidityPredicateCircuit;
+//     use std::io::Write;
+
+//     let params = SETUP_PARAMS_MAP.get(&VP_CIRCUIT_PARAMS_SIZE).unwrap();
+//     let empty_circuit = TrivialValidityPredicateCircuit::default();
+//     let vk = keygen_vk(params, &empty_circuit).expect("keygen_vk should not fail");
+//     let pk = keygen_pk(params, vk, &empty_circuit).expect("keygen_pk should not fail");
+//     let mut bytes = vec![];
+//     pk.write(&mut bytes).unwrap();
+//     let mut file = std::fs::File::create("./params/trivial_vp_proving_key")
+//         .unwrap_or_else(|err| panic!("cannot create trivial_vp_proving_key with {}", err));
+//     file.write_all(&bytes).unwrap();
+// }
diff --git a/taiga_halo2/src/transaction.rs b/taiga_halo2/src/transaction.rs
index 4b40b587..7d8d91be 100644
--- a/taiga_halo2/src/transaction.rs
+++ b/taiga_halo2/src/transaction.rs
@@ -338,7 +338,7 @@ pub mod testing {
 
         let rng = OsRng;
 
-        let shielded_ptx_bundle = create_shielded_ptx_bundle(2);
+        let shielded_ptx_bundle = create_shielded_ptx_bundle(1);
         // TODO: add transparent_ptx_bundle test
         let transparent_ptx_bundle = TransparentPartialTxBundle::default();
         let tx = Transaction::build(rng, shielded_ptx_bundle, transparent_ptx_bundle);