diff --git a/crates/protocol/src/lib.rs b/crates/protocol/src/lib.rs
index 3d19ca7..9c2759d 100644
--- a/crates/protocol/src/lib.rs
+++ b/crates/protocol/src/lib.rs
@@ -264,17 +264,7 @@ impl Protocol {
                 let approved_stake = match Self::validate_signature(approval_message, sig, pk) {
                     Ok(_) => approved_stake + stake,
                     Err(Error::SignatureInvalid) => {
-                        log::debug!(
-                            "invalid signature: pk: {} sig: {:?}",
-                            hex::encode(pk.unwrap_as_ed25519().0),
-                            sig.clone().map(|s| {
-                                if let Signature::ED25519(s) = *s {
-                                    hex::encode(s.r_bytes())
-                                } else {
-                                    unreachable!()
-                                }
-                            })
-                        );
+                        log::debug!("invalid signature: pk: {} sig: {:?}", pk, sig);
                         approved_stake
                     }
                     Err(Error::ValidatorNotSigned) => approved_stake,
diff --git a/nearx/src/builder.rs b/nearx/src/builder.rs
index 797488b..07475b2 100644
--- a/nearx/src/builder.rs
+++ b/nearx/src/builder.rs
@@ -11,9 +11,9 @@ use pretty_assertions::assert_eq;
 use crate::{
     merkle::{MerklePathVariable, NearMerkleTree},
     variables::{
-        ApprovalMessage, BlockHeightVariable, BlockVariable, BpsApprovals, BpsArr,
-        BuildEndorsement, CryptoHashVariable, HeaderVariable, ProofVariable, PublicKeyVariable,
-        StakeInfoVariable, ValidatorStakeVariable,
+        ApprovalMessage, BlockHeightVariable, BlockVariable, BpsApprovals, BuildEndorsement,
+        CryptoHashVariable, HeaderVariable, ProofVariable, PublicKeyVariable, StakeInfoVariable,
+        Validators,
     },
 };
 
@@ -30,17 +30,17 @@ pub trait Ensure<L: PlonkParameters<D>, const D: usize> {
         epoch_id: &CryptoHashVariable,
     ) -> BoolVariable;
 
-    fn ensure_if_next_epoch_contains_next_bps(
+    fn ensure_if_next_epoch_contains_next_bps<const LEN: usize>(
         &mut self,
         head: &HeaderVariable,
         epoch_id: &CryptoHashVariable,
-        next_bps: &BpsArr<ValidatorStakeVariable>,
+        next_bps: &Validators<LEN>,
     ) -> BoolVariable;
 
     fn validate_signatures<const LEN: usize>(
         &mut self,
         approvals: &BpsApprovals<LEN>,
-        bps: &BpsArr<ValidatorStakeVariable, LEN>,
+        bps: &Validators<LEN>,
         approval_message: ApprovalMessage,
     ) -> StakeInfoVariable;
 
@@ -102,14 +102,14 @@ impl<L: PlonkParameters<D>, const D: usize> Ensure<L, D> for CircuitBuilder<L, D
         self.or(this, next)
     }
 
-    fn ensure_if_next_epoch_contains_next_bps(
+    fn ensure_if_next_epoch_contains_next_bps<const LEN: usize>(
         &mut self,
         head: &HeaderVariable,
         epoch_id: &CryptoHashVariable,
-        next_bps: &BpsArr<ValidatorStakeVariable>,
+        next_bps: &Validators<LEN>,
     ) -> BoolVariable {
         let is_next_epoch = self.is_equal(head.inner_lite.next_epoch_id, *epoch_id);
-        let is_not_empty = self.constant(next_bps.len() > 0);
+        let is_not_empty = self.constant(next_bps.inner.len() > 0);
         let ok_anyway = self._true();
         self.select(is_next_epoch, is_not_empty, ok_anyway)
     }
@@ -117,12 +117,12 @@ impl<L: PlonkParameters<D>, const D: usize> Ensure<L, D> for CircuitBuilder<L, D
     fn validate_signatures<const LEN: usize>(
         &mut self,
         approvals_after_next: &BpsApprovals<LEN>,
-        epoch_bps: &BpsArr<ValidatorStakeVariable, LEN>,
+        epoch_bps: &Validators<LEN>,
         approval_message: ApprovalMessage,
     ) -> StakeInfoVariable {
         assert_eq!(approvals_after_next.is_active.len(), LEN);
         assert_eq!(approvals_after_next.signatures.len(), LEN);
-        assert_eq!(epoch_bps.data.len(), LEN);
+        assert_eq!(epoch_bps.inner.len(), LEN);
 
         let messages = [approval_message; LEN];
 
@@ -135,7 +135,7 @@ impl<L: PlonkParameters<D>, const D: usize> Ensure<L, D> for CircuitBuilder<L, D
         let mut approved_stake = self.zero();
 
         for i in 0..LEN {
-            let vs = &epoch_bps.data[i];
+            let vs = &epoch_bps.inner.data[i];
 
             let is_dummy = self.is_equal(dummy_pk.clone(), vs.public_key.clone());
             let sig_active = approvals_after_next.is_active[i];
@@ -249,22 +249,25 @@ impl<L: PlonkParameters<D>, const D: usize> Ensure<L, D> for CircuitBuilder<L, D
 }
 
 pub trait Sync<L: PlonkParameters<D>, const D: usize> {
-    fn sync(
+    fn sync<const LEN: usize>(
         &mut self,
         head: &HeaderVariable,
-        epoch_bps: &BpsArr<ValidatorStakeVariable>,
-        next_block: &BlockVariable,
+        epoch_bps: &Validators<LEN>,
+        next_block: &BlockVariable<LEN>,
     ) -> HeaderVariable;
 
-    fn reconstruct_approval_message(&mut self, next_block: &BlockVariable) -> ApprovalMessage;
+    fn reconstruct_approval_message<const LEN: usize>(
+        &mut self,
+        next_block: &BlockVariable<LEN>,
+    ) -> ApprovalMessage;
 }
 
 impl<L: PlonkParameters<D>, const D: usize> Sync<L, D> for CircuitBuilder<L, D> {
-    fn sync(
+    fn sync<const LEN: usize>(
         &mut self,
         head: &HeaderVariable,
-        epoch_bps: &BpsArr<ValidatorStakeVariable>,
-        next_block: &BlockVariable,
+        epoch_bps: &Validators<LEN>,
+        next_block: &BlockVariable<LEN>,
     ) -> HeaderVariable {
         let not_verified =
             self.ensure_not_already_verified(head, &next_block.header.inner_lite.height);
@@ -300,12 +303,15 @@ impl<L: PlonkParameters<D>, const D: usize> Sync<L, D> for CircuitBuilder<L, D>
             &next_block.next_bps_hash,
         );
         self.assertx(bps_valid);
-        assert!(next_block.next_bps.len() == NUM_BLOCK_PRODUCER_SEATS);
+        assert!(next_block.next_bps.inner.len() == NUM_BLOCK_PRODUCER_SEATS);
 
         next_block.header.to_owned()
     }
 
-    fn reconstruct_approval_message(&mut self, next_block: &BlockVariable) -> ApprovalMessage {
+    fn reconstruct_approval_message<const LEN: usize>(
+        &mut self,
+        next_block: &BlockVariable<LEN>,
+    ) -> ApprovalMessage {
         let next_header_hash = next_block.header.hash(self);
         let next_block_hash =
             self.curta_sha256_pair(next_block.next_block_inner_hash, next_header_hash);
@@ -482,7 +488,7 @@ mod tests {
 
         let define = |builder: &mut B| {
             let header = builder.read::<HeaderVariable>();
-            let next_bps = builder.read::<BpsArr<ValidatorStakeVariable>>();
+            let next_bps = builder.read::<Validators>();
 
             let current =
                 builder.ensure_epoch_is_current_or_next(&header, &header.inner_lite.epoch_id);
@@ -505,7 +511,7 @@ mod tests {
         };
         let writer = |input: &mut PI| {
             input.write::<HeaderVariable>(header.clone().into());
-            input.write::<BpsArr<ValidatorStakeVariable>>(bps_to_variable(Some(bps)));
+            input.write::<Validators>(ValidatorsVariableValue::from_iter(bps));
         };
         let assertions = |mut output: PO| {
             assert!(output.read::<BoolVariable>(), "epoch is current");
@@ -520,12 +526,12 @@ mod tests {
     fn test_reconstruct_approval_msg() {
         let (_, _, next_block) = test_state();
         let define = |builder: &mut B| {
-            let next_block = builder.read::<BlockVariable>();
+            let next_block = builder.read::<BlockVariable<NUM_BLOCK_PRODUCER_SEATS>>();
             let os = builder.reconstruct_approval_message(&next_block);
             builder.write::<ApprovalMessage>(os);
         };
         let writer = |input: &mut PI| {
-            input.write::<BlockVariable>(next_block.clone().into());
+            input.write::<BlockVariable<NUM_BLOCK_PRODUCER_SEATS>>(next_block.clone().into());
         };
         let assertions = |mut output: PO| {
             let created = output.read::<ApprovalMessage>();
@@ -539,7 +545,7 @@ mod tests {
     fn test_raw_le_bytes() {
         let (_, _, next_block) = test_state();
         let define = |builder: &mut B| {
-            let next_block = builder.read::<BlockVariable>();
+            let next_block = builder.read::<BlockVariable<NUM_BLOCK_PRODUCER_SEATS>>();
 
             let mut bytes = vec![];
             for target in next_block.header.inner_lite.height.targets() {
@@ -558,7 +564,7 @@ mod tests {
             builder.write::<BytesVariable<8>>(BytesVariable(bytes.try_into().unwrap()));
         };
         let writer = |input: &mut PI| {
-            input.write::<BlockVariable>(next_block.clone().into());
+            input.write::<BlockVariable<NUM_BLOCK_PRODUCER_SEATS>>(next_block.clone().into());
         };
         let assertions = |mut output: PO| {
             let bytes = output.read::<BytesVariable<8>>();
@@ -576,6 +582,7 @@ mod tests {
 /// TODO: CI for only beefy tests
 #[cfg(test)]
 mod beefy_tests {
+    use near_light_client_primitives::NUM_BLOCK_PRODUCER_SEATS;
     use serial_test::serial;
 
     use crate::{
@@ -593,7 +600,7 @@ mod beefy_tests {
 
         let define = |builder: &mut B| {
             let header = builder.read::<HeaderVariable>();
-            let next_bps = builder.read::<BpsArr<ValidatorStakeVariable>>();
+            let next_bps = builder.read::<Validators>();
 
             let current =
                 builder.ensure_epoch_is_current_or_next(&header, &header.inner_lite.epoch_id);
@@ -616,7 +623,7 @@ mod beefy_tests {
         };
         let writer = |input: &mut PI| {
             input.write::<HeaderVariable>(header.clone().into());
-            input.write::<BpsArr<ValidatorStakeVariable>>(bps_to_variable(Some(bps)));
+            input.write::<Validators>(ValidatorsVariableValue::from_iter(bps));
         };
         let assertions = |mut output: PO| {
             assert!(output.read::<BoolVariable>(), "epoch is current");
@@ -662,15 +669,17 @@ mod beefy_tests {
 
         let define = |builder: &mut B| {
             let head = builder.read::<HeaderVariable>();
-            let bps = builder.read::<BpsArr<ValidatorStakeVariable>>();
-            let next_block = builder.read::<BlockVariable>();
+            let bps = builder.read::<Validators>();
+            let next_block = builder.read::<BlockVariable<NUM_BLOCK_PRODUCER_SEATS>>();
             let synced = builder.sync(&head, &bps, &next_block);
             builder.write::<HeaderVariable>(synced);
         };
         let writer = |input: &mut PI| {
             input.write::<HeaderVariable>(head.into());
-            input.write::<BpsArr<ValidatorStakeVariable>>(bps_to_variable(Some(next_bps)));
-            input.write::<BlockVariable>(next_block.clone().into());
+            input.write::<Validators<NUM_BLOCK_PRODUCER_SEATS>>(
+                ValidatorsVariableValue::from_iter(next_bps),
+            );
+            input.write::<BlockVariable<NUM_BLOCK_PRODUCER_SEATS>>(next_block.clone().into());
         };
         let assertions = |mut output: PO| {
             let header = output.read::<HeaderVariable>();
@@ -686,18 +695,17 @@ mod beefy_tests {
     fn beefy_builder_test_bounded_signatures() {
         let (_, bps, next_block) = test_state();
         const BPS_AMT: usize = 15;
+        let r = 0..BPS_AMT;
 
         let define = |builder: &mut B| {
-            let bps = builder.read::<BpsArr<ValidatorStakeVariable, BPS_AMT>>();
-            let next_block = builder.read::<BlockVariable>();
+            let bps = builder.read::<Validators<BPS_AMT>>();
+            let next_block = builder.read::<BlockVariable<NUM_BLOCK_PRODUCER_SEATS>>();
 
             let next_block_approvals = BpsApprovals {
-                signatures: next_block.approvals_after_next.signatures[0..BPS_AMT]
-                    .to_vec()
-                    .into(),
-                is_active: next_block.approvals_after_next.is_active[0..BPS_AMT]
+                signatures: next_block.approvals_after_next.signatures[r.clone()]
                     .to_vec()
                     .into(),
+                is_active: next_block.approvals_after_next.is_active[r].to_vec().into(),
             };
 
             let msg = builder.reconstruct_approval_message(&next_block);
@@ -705,10 +713,8 @@ mod beefy_tests {
             builder.validate_signatures(&next_block_approvals, &bps, msg);
         };
         let writer = |input: &mut PI| {
-            input.write::<BpsArr<ValidatorStakeVariable, BPS_AMT>>(
-                bps_to_variable(Some(bps.clone()))[0..BPS_AMT].into(),
-            );
-            input.write::<BlockVariable>(next_block.into());
+            input.write::<Validators<BPS_AMT>>(bps.into_iter().collect());
+            input.write::<BlockVariable<NUM_BLOCK_PRODUCER_SEATS>>(next_block.into());
         };
         let assertions = |mut _output: PO| {};
         builder_suite(define, writer, assertions);
diff --git a/nearx/src/hint.rs b/nearx/src/hint.rs
index 34b607a..1df5c1e 100644
--- a/nearx/src/hint.rs
+++ b/nearx/src/hint.rs
@@ -2,6 +2,7 @@ use std::{collections::HashMap, marker::PhantomData};
 
 use async_trait::async_trait;
 use log::debug;
+use near_light_client_primitives::NUM_BLOCK_PRODUCER_SEATS;
 use near_light_client_protocol::{prelude::CryptoHash, Proof};
 use near_light_client_rpc::{prelude::GetProof, LightClientRpc, NearRpcClient, Network};
 use plonky2x::{
@@ -11,9 +12,9 @@ use plonky2x::{
 use serde::{Deserialize, Serialize};
 
 use crate::variables::{
-    bps_to_variable, normalise_account_id, BlockVariable, BlockVariableValue, BpsArr,
-    CryptoHashVariable, HeaderVariable, ProofVariable, TransactionOrReceiptIdVariable,
-    ValidatorStakeVariable,
+    normalise_account_id, BlockVariable, BlockVariableValue, CryptoHashVariable, HeaderVariable,
+    ProofVariable, TransactionOrReceiptIdVariable, Validators, ValidatorsVariable,
+    ValidatorsVariableValue,
 };
 
 #[derive(Debug, Clone, Deserialize, Serialize)]
@@ -36,21 +37,21 @@ impl<L: PlonkParameters<D>, const D: usize> AsyncHint<L, D> for FetchNextHeaderI
             .expect("Failed to fetch header")
             .expect("Expected a header");
 
-        output_stream.write_value::<BlockVariable>(next.into());
+        output_stream.write_value::<BlockVariable<NUM_BLOCK_PRODUCER_SEATS>>(next.into());
     }
 }
 
 impl FetchNextHeaderInputs {
-    pub fn fetch<L: PlonkParameters<D>, const D: usize>(
+    pub fn fetch<L: PlonkParameters<D>, const D: usize, const LEN: usize>(
         &self,
         b: &mut CircuitBuilder<L, D>,
         hash: &CryptoHashVariable,
-    ) -> Option<BlockVariable> {
+    ) -> Option<BlockVariable<LEN>> {
         let mut input_stream = VariableStream::new();
         input_stream.write::<CryptoHashVariable>(hash);
 
         let output_stream = b.async_hint(input_stream, self.clone());
-        Some(output_stream.read::<BlockVariable>(b))
+        Some(output_stream.read::<BlockVariable<LEN>>(b))
     }
 }
 
@@ -101,36 +102,36 @@ pub enum Fetch {
     },
 }
 
-pub enum Inputs {
+pub enum Inputs<const N: usize> {
     Sync {
         header: HeaderVariable,
-        bps: BpsArr<ValidatorStakeVariable>,
-        next_block: BlockVariable,
+        bps: Validators<N>,
+        next_block: BlockVariable<N>,
     },
 }
 
-impl Inputs {
+impl<const N: usize> Inputs<N> {
     fn validate<L: PlonkParameters<D>, const D: usize>(&self, b: &mut CircuitBuilder<L, D>) {
-        // TODO: validate based on inputs
+        // TODO: validate based on inputs, here is where we might entrust
+        // untrusted headers and such
     }
 }
 
 #[derive(Debug, Clone, Deserialize, Serialize)]
-pub struct InputFetcher<L: PlonkParameters<D>, const D: usize, const NETWORK: usize>(
-    PhantomData<L>,
+pub struct InputFetcher<L: PlonkParameters<D>, const D: usize, const N: usize>(
+    (Network, PhantomData<(L)>),
 );
 
 #[async_trait]
-impl<L: PlonkParameters<D>, const D: usize, const NETWORK: usize> AsyncHint<L, D>
-    for InputFetcher<L, D, NETWORK>
+impl<L: PlonkParameters<D>, const D: usize, const N: usize> AsyncHint<L, D>
+    for InputFetcher<L, D, N>
 {
     async fn hint(
         &self,
         input_stream: &mut ValueStream<L, D>,
         output_stream: &mut ValueStream<L, D>,
     ) {
-        let network: Network = NETWORK.into();
-        let client = NearRpcClient::new(&network.into());
+        let client = NearRpcClient::new(&self.0 .0.clone().into());
 
         let marker: L::Field = input_stream.read_value::<Variable>();
         let marker = marker.to_canonical_u64();
@@ -158,13 +159,9 @@ impl<L: PlonkParameters<D>, const D: usize, const NETWORK: usize> AsyncHint<L, D
                     .expect("Failed to fetch header")
                     .expect("Expected a header");
 
-                output_stream.write_value::<HeaderVariable>(header.into());
-                output_stream.write_value::<BpsArr<ValidatorStakeVariable>>(bps_to_variable(bps));
-                output_stream.write_value::<BlockVariable>(next_block.into());
-
                 let header_var = header.into();
-                let bps_var = bps_to_variable(bps);
-                let next_block_var: BlockVariableValue<_> = next_block.into();
+                let bps_var = ValidatorsVariableValue::from_iter(bps.unwrap());
+                let next_block_var: BlockVariableValue<N, _> = next_block.into();
 
                 use ethers::utils::hex;
                 next_block_var
@@ -176,23 +173,24 @@ impl<L: PlonkParameters<D>, const D: usize, const NETWORK: usize> AsyncHint<L, D
                     .for_each(|(i, (x, y))| {
                         log::debug!(
                             "bps({i}): {:?} sig: {:?} active: {:?}",
-                            hex::encode(bps_var[i].public_key.0),
+                            hex::encode(bps_var.inner[i].public_key.0),
                             hex::encode(y.r.0),
                             x
                         );
                     });
 
                 output_stream.write_value::<HeaderVariable>(header_var);
-                output_stream.write_value::<BpsArr<ValidatorStakeVariable>>(bps_var);
-                output_stream.write_value::<BlockVariable>(next_block_var);
+                // TODO: fix the bounding issue here
+                output_stream.write_value::<Validators<N>>(bps_var);
+                output_stream.write_value::<BlockVariable<N>>(next_block_var);
             }
             _ => panic!("Invalid marker"),
         }
     }
 }
 
-impl<L: PlonkParameters<D>, const D: usize, const NETWORK: usize> InputFetcher<L, D, NETWORK> {
-    pub fn fetch(&self, b: &mut CircuitBuilder<L, D>, args: &Fetch) -> Inputs {
+impl<L: PlonkParameters<D>, const D: usize, const N: usize> InputFetcher<L, D, N> {
+    pub fn fetch(&self, b: &mut CircuitBuilder<L, D>, args: &Fetch) -> Inputs<N> {
         let mut input_stream = VariableStream::new();
         match args {
             Fetch::Sync {
@@ -207,8 +205,8 @@ impl<L: PlonkParameters<D>, const D: usize, const NETWORK: usize> InputFetcher<L
         match args {
             Fetch::Sync { .. } => {
                 let header = output_stream.read::<HeaderVariable>(b);
-                let bps = output_stream.read::<BpsArr<ValidatorStakeVariable>>(b);
-                let next_block = output_stream.read::<BlockVariable>(b);
+                let bps = output_stream.read::<Validators<N>>(b);
+                let next_block = output_stream.read::<BlockVariable<N>>(b);
                 Inputs::Sync {
                     header,
                     bps,
@@ -221,13 +219,9 @@ impl<L: PlonkParameters<D>, const D: usize, const NETWORK: usize> InputFetcher<L
         &self,
         b: &mut CircuitBuilder<L, D>,
         untrusted_header_hash: &CryptoHashVariable,
-    ) -> (
-        HeaderVariable,
-        BpsArr<ValidatorStakeVariable>,
-        BlockVariable,
-    ) {
-        let fetch_header = FetchHeaderInputs(NETWORK.into());
-        let fetch_next_header = FetchNextHeaderInputs(NETWORK.into());
+    ) -> (HeaderVariable, Validators<N>, BlockVariable<N>) {
+        let fetch_header = FetchHeaderInputs(self.0 .0.into());
+        let fetch_next_header = FetchNextHeaderInputs(self.0 .0.into());
 
         let header = fetch_header.fetch(b, &untrusted_header_hash);
         let bps = fetch_next_header
@@ -361,24 +355,24 @@ mod tests {
             let header = b.read::<HeaderVariable>();
             let hash = header.hash(b);
             let next_block = FetchNextHeaderInputs(Network::Mainnet).fetch(b, &hash);
-            b.write::<BlockVariable>(next_block.unwrap());
+            b.write::<BlockVariable<NUM_BLOCK_PRODUCER_SEATS>>(next_block.unwrap());
 
             let header = b.read::<HeaderVariable>();
             let hash = header.hash(b);
             let next_block = FetchNextHeaderInputs(Network::Testnet).fetch(b, &hash);
-            b.write::<BlockVariable>(next_block.unwrap());
+            b.write::<BlockVariable<NUM_BLOCK_PRODUCER_SEATS>>(next_block.unwrap());
         };
         let writer = |input: &mut PI| {
             input.write::<HeaderVariable>(main_h.into());
             input.write::<HeaderVariable>(test_h.into());
         };
         let assertions = |mut output: PO| {
-            let inputs = output.read::<BlockVariable>();
-            let nbh: BlockVariableValue<GoldilocksField> = main_nb.into();
+            let inputs = output.read::<BlockVariable<NUM_BLOCK_PRODUCER_SEATS>>();
+            let nbh: BlockVariableValue<NUM_BLOCK_PRODUCER_SEATS, GoldilocksField> = main_nb.into();
             pretty_assertions::assert_eq!(format!("{:#?}", inputs), format!("{:#?}", nbh));
 
-            let inputs = output.read::<BlockVariable>();
-            let nbh: BlockVariableValue<GoldilocksField> = test_nb.into();
+            let inputs = output.read::<BlockVariable<NUM_BLOCK_PRODUCER_SEATS>>();
+            let nbh: BlockVariableValue<NUM_BLOCK_PRODUCER_SEATS, GoldilocksField> = test_nb.into();
             pretty_assertions::assert_eq!(format!("{:#?}", inputs), format!("{:#?}", nbh));
         };
         builder_suite(define, writer, assertions);
@@ -389,7 +383,8 @@ mod tests {
         let problem_hash =
             bytes32!("0xeff7dccf304315aa520ad7e704062a8b8deadc5c0906e7e16d7305067a72a57e");
         //let problem_hash = testnet_state().0.hash().0;
-        let fetcher = InputFetcher::<DefaultParameters, 2, 1>(Default::default());
+        const AMT: usize = 50;
+        let fetcher = InputFetcher::<DefaultParameters, 2, AMT>(Default::default());
 
         let define = |b: &mut B| {
             let trusted_header_hash = b.read::<CryptoHashVariable>();
@@ -407,8 +402,8 @@ mod tests {
 
             // TODO: validate
             b.write::<HeaderVariable>(header.clone());
-            b.write::<BpsArr<ValidatorStakeVariable>>(bps.clone());
-            b.write::<BlockVariable>(next_block.clone());
+            b.write::<ValidatorsVariable<AMT>>(bps.clone());
+            b.write::<BlockVariable<AMT>>(next_block.clone());
 
             let approval = b.reconstruct_approval_message(&next_block);
             b.validate_signatures(&next_block.approvals_after_next, &bps, approval);
@@ -423,21 +418,25 @@ mod tests {
         };
         builder_suite(define, writer, assertions);
 
-        let head = serde_json::from_str::<LightClientBlockLiteView>(
-            std::fs::read_to_string("header.json").unwrap().as_str(),
-        )
-        .unwrap();
-        let epoch_bps: Vec<ValidatorStake> = serde_json::from_str::<Vec<ValidatorStakeView>>(
-            std::fs::read_to_string("bps.json").unwrap().as_str(),
-        )
-        .unwrap()
-        .into_iter()
-        .map(ValidatorStakeView::into)
-        .collect();
-        let next_block = serde_json::from_str::<LightClientBlockView>(
-            std::fs::read_to_string("next_block.json").unwrap().as_str(),
-        )
-        .unwrap();
-        near_light_client_protocol::Protocol::sync(&head, &epoch_bps, next_block).unwrap();
+        // TODO: everything doing anything sync wise should also verify with the
+        // data in the base protocol, if possible
+        // let head = serde_json::from_str::<LightClientBlockLiteView>(
+        //     std::fs::read_to_string("header.json").unwrap().as_str(),
+        // )
+        // .unwrap();
+        // let epoch_bps: Vec<ValidatorStake> =
+        // serde_json::from_str::<Vec<ValidatorStakeView>>(
+        //     std::fs::read_to_string("bps.json").unwrap().as_str(),
+        // )
+        // .unwrap()
+        // .into_iter()
+        // .map(ValidatorStakeView::into)
+        // .collect();
+        // let next_block = serde_json::from_str::<LightClientBlockView>(
+        //     std::fs::read_to_string("next_block.json").unwrap().as_str(),
+        // )
+        // .unwrap();
+        // near_light_client_protocol::Protocol::sync(&head, &epoch_bps,
+        // next_block).unwrap();
     }
 }
diff --git a/nearx/src/variables.rs b/nearx/src/variables.rs
index f7a1737..9bf0984 100644
--- a/nearx/src/variables.rs
+++ b/nearx/src/variables.rs
@@ -30,6 +30,7 @@ use crate::merkle::MerklePathVariable;
 
 /// Type for omitting the size across the codebase for arrays that are the same
 /// size as BPS
+pub(crate) type Validators<const A: usize = NUM_BLOCK_PRODUCER_SEATS> = ValidatorsVariable<A>;
 pub(crate) type BpsArr<T, const A: usize = NUM_BLOCK_PRODUCER_SEATS> = ArrayVariable<T, A>;
 
 pub type CryptoHashVariable = Bytes32Variable;
@@ -312,15 +313,15 @@ impl<L: PlonkParameters<D>, const D: usize> Hint<L, D> for EncodeInner {
 }
 
 #[derive(CircuitVariable, Clone, Debug)]
-pub struct BlockVariable {
+pub struct BlockVariable<const LEN: usize> {
     pub header: HeaderVariable,
     pub next_block_inner_hash: CryptoHashVariable,
-    pub next_bps: BpsArr<ValidatorStakeVariable>,
-    pub approvals_after_next: BpsApprovals<NUM_BLOCK_PRODUCER_SEATS>,
+    pub next_bps: Validators<LEN>,
+    pub approvals_after_next: BpsApprovals<LEN>,
     pub next_bps_hash: CryptoHashVariable,
 }
 
-impl<F: RichField> From<LightClientBlockView> for BlockVariableValue<F> {
+impl<F: RichField, const LEN: usize> From<LightClientBlockView> for BlockVariableValue<LEN, F> {
     fn from(block: LightClientBlockView) -> Self {
         let next_bps_hash = block
             .next_bps
@@ -333,19 +334,16 @@ impl<F: RichField> From<LightClientBlockView> for BlockVariableValue<F> {
         let variable = Self {
             next_block_inner_hash: block.next_block_inner_hash.0.into(),
             header: block.clone().into(),
-            next_bps: bps_to_variable(block.next_bps),
+            next_bps: block
+                .next_bps
+                .map(|bps| bps.into_iter().collect())
+                .unwrap_or_default(),
             approvals_after_next: block.approvals_after_next.into(),
             next_bps_hash,
         };
-        assert_eq!(variable.next_bps.len(), NUM_BLOCK_PRODUCER_SEATS);
-        assert_eq!(
-            variable.approvals_after_next.is_active.len(),
-            NUM_BLOCK_PRODUCER_SEATS
-        );
-        assert_eq!(
-            variable.approvals_after_next.signatures.len(),
-            NUM_BLOCK_PRODUCER_SEATS
-        );
+        assert_eq!(variable.next_bps.inner.len(), LEN);
+        assert_eq!(variable.approvals_after_next.is_active.len(), LEN);
+        assert_eq!(variable.approvals_after_next.signatures.len(), LEN);
         variable
     }
 }
@@ -365,7 +363,6 @@ impl<F: RichField, const AMT: usize> From<Vec<Option<Box<Signature>>>>
             .into_iter()
             .take(AMT)
             .map(|s| {
-                // FIXME: heres the problem, active signature, no bps
                 let is_active = s.is_some();
                 let s: SignatureVariableValue<F> = s.into();
 
@@ -380,24 +377,6 @@ impl<F: RichField, const AMT: usize> From<Vec<Option<Box<Signature>>>>
     }
 }
 
-// TODO: tie this in with the From implementation and newtype it
-pub(crate) fn bps_to_variable<F: RichField, T: Into<ValidatorStake>>(
-    next_bps: Option<Vec<T>>,
-) -> Vec<ValidatorStakeVariableValue<F>> {
-    next_bps
-        .map(|next_bps| {
-            let mut bps = next_bps
-                .into_iter()
-                .take(NUM_BLOCK_PRODUCER_SEATS)
-                .map(Into::<ValidatorStake>::into)
-                .map(Into::<ValidatorStakeVariableValue<F>>::into)
-                .collect_vec();
-            bps.resize(NUM_BLOCK_PRODUCER_SEATS, Default::default());
-            bps
-        })
-        .unwrap_or_else(|| vec![Default::default(); NUM_BLOCK_PRODUCER_SEATS])
-}
-
 #[derive(CircuitVariable, Clone, Debug)]
 pub struct ValidatorStakeVariable {
     // TODO[optimisation]: can optimise this out by witnessing the hash
@@ -421,8 +400,8 @@ impl<F: RichField> From<ValidatorStake> for ValidatorStakeVariableValue<F> {
 
 impl<F: RichField> From<ValidatorStakeVariableValue<F>> for ValidatorStakeView {
     fn from(val: ValidatorStakeVariableValue<F>) -> Self {
-        let account_id = normalise_account_id::<F>(&val.account_id);
         let public_key = PublicKey::ED25519(ED25519PublicKey(val.public_key.0));
+        let account_id = normalise_account_id::<F>(&val.account_id);
         ValidatorStakeView::V1(ValidatorStakeViewV1 {
             account_id,
             public_key,
@@ -431,6 +410,35 @@ impl<F: RichField> From<ValidatorStakeVariableValue<F>> for ValidatorStakeView {
     }
 }
 
+#[derive(CircuitVariable, Clone, Debug)]
+pub struct ValidatorsVariable<const N: usize> {
+    pub(crate) inner: BpsArr<ValidatorStakeVariable, N>,
+}
+
+impl<F: RichField, I: Into<ValidatorStakeView>, const N: usize> FromIterator<I>
+    for ValidatorsVariableValue<N, F>
+{
+    fn from_iter<T: IntoIterator<Item = I>>(iter: T) -> Self {
+        let mut bps = iter
+            .into_iter()
+            .take(N)
+            .map(Into::<ValidatorStakeView>::into)
+            .map(Into::<ValidatorStake>::into)
+            .map(Into::<ValidatorStakeVariableValue<F>>::into)
+            .collect_vec();
+        bps.resize(N, Default::default());
+        Self { inner: bps }
+    }
+}
+
+impl<F: RichField, const N: usize> Default for ValidatorsVariableValue<N, F> {
+    fn default() -> Self {
+        Self {
+            inner: vec![Default::default(); N],
+        }
+    }
+}
+
 impl<F: RichField> Default for ValidatorStakeVariableValue<F> {
     fn default() -> Self {
         let account_id: [u8; AccountId::MAX_LEN] = [ACCOUNT_DATA_SEPARATOR; AccountId::MAX_LEN];
@@ -566,12 +574,13 @@ pub struct HashBpsInputs;
 
 impl<L: PlonkParameters<D>, const D: usize> Hint<L, D> for HashBpsInputs {
     fn hint(&self, input_stream: &mut ValueStream<L, D>, output_stream: &mut ValueStream<L, D>) {
-        let bps = input_stream.read_value::<BpsArr<ValidatorStakeVariable>>();
+        let bps = input_stream.read_value::<Validators>();
         // TODO: if we use a bitmask we wont need default checks
         let default_validator =
             ValidatorStakeVariableValue::<<L as PlonkParameters<D>>::Field>::default();
 
         let bps = bps
+            .inner
             .into_iter()
             .filter(|x| x.account_id != default_validator.account_id)
             .map(Into::<ValidatorStakeView>::into)
@@ -590,10 +599,10 @@ impl HashBpsInputs {
     pub fn hash<L: PlonkParameters<D>, const D: usize>(
         self,
         b: &mut CircuitBuilder<L, D>,
-        bps: &BpsArr<ValidatorStakeVariable>,
+        bps: &Validators,
     ) -> CryptoHashVariable {
         let mut input_stream = VariableStream::new();
-        input_stream.write::<BpsArr<ValidatorStakeVariable>>(bps);
+        input_stream.write::<Validators>(bps);
 
         let output_stream = b.hint(input_stream, self);
         output_stream.read::<CryptoHashVariable>(b)