diff --git a/libraries/chain/block_header_state.cpp b/libraries/chain/block_header_state.cpp
index b105d63e12..c73b39a135 100644
--- a/libraries/chain/block_header_state.cpp
+++ b/libraries/chain/block_header_state.cpp
@@ -4,16 +4,6 @@
 
 namespace eosio::chain {
 
-namespace detail {
-
-uint32_t get_next_next_round_block_num(block_timestamp_type t, uint32_t block_num) {
-   auto index = t.slot % config::producer_repetitions; // current index in current round
-   //                 (increment to the end of this round  ) + next round
-   return block_num + (config::producer_repetitions - index) + config::producer_repetitions;
-}
-
-} // namespace detail
-
 block_header_state_core block_header_state_core::next(uint32_t last_qc_block_height, bool is_last_qc_strong) const {
    // no state change if last_qc_block_height is the same
    if (last_qc_block_height == this->last_qc_block_height) {
diff --git a/libraries/chain/controller.cpp b/libraries/chain/controller.cpp
index 83ab154bb1..69743cbe49 100644
--- a/libraries/chain/controller.cpp
+++ b/libraries/chain/controller.cpp
@@ -119,6 +119,8 @@ class maybe_session {
 struct completed_block {
    std::variant<block_state_legacy_ptr, block_state_ptr> bsp;
 
+   bool is_dpos() const { return std::holds_alternative<block_state_legacy_ptr>(bsp); }
+
    deque<transaction_metadata_ptr> extract_trx_metas() {
       return std::visit(overloaded{[](block_state_legacy_ptr& bsp) { return bsp->extract_trxs_metas(); },
                                    [](block_state_ptr& bsp)        { return bsp->extract_trxs_metas(); }},
@@ -168,7 +170,7 @@ struct completed_block {
                                       const auto& sch = bsp->bhs.new_pending_producer_schedule();
                                       if (sch)
                                          return *sch;
-                                      return active_producers();  // [greg todo: Is this correct?]
+                                      return active_producers();  // [greg todo: Is this correct?] probably not
                                    }},
                         bsp);
    }
@@ -215,6 +217,8 @@ struct assembled_block {
 
    std::variant<assembled_block_dpos, assembled_block_if> v;
 
+   bool is_dpos() const { return std::holds_alternative<assembled_block_dpos>(v); }
+
    template <class R, class F>
    R apply_dpos(F&& f) {
       return std::visit(overloaded{[&](assembled_block_dpos& ab) -> R { return std::forward<F>(f)(ab); },
@@ -270,21 +274,33 @@ struct assembled_block {
    }
 
    const producer_authority_schedule& active_producers() const {
-      return std::visit(overloaded{[](const assembled_block_dpos& bb) -> const producer_authority_schedule& {
-                                      return bb.pending_block_header_state.active_schedule;
+      return std::visit(overloaded{[](const assembled_block_dpos& ab) -> const producer_authority_schedule& {
+                                      return ab.pending_block_header_state.active_schedule;
                                    },
-                                   [](const assembled_block_if& bb) -> const producer_authority_schedule& {
+                                   [](const assembled_block_if& ab) -> const producer_authority_schedule& {
                                       static producer_authority_schedule pas; return pas; // [greg todo]
                                    }},
                         v);
    }
 
+   using opt_pas = const std::optional<producer_authority_schedule>;
+
+   opt_pas& pending_producers() const {
+      return std::visit(
+         overloaded{[](const assembled_block_dpos& ab) -> opt_pas& { return ab.new_producer_authority_cache; },
+                    [](const assembled_block_if& ab) -> opt_pas& {
+                       static opt_pas empty;
+                       return empty; // [greg todo]
+                    }},
+         v);
+   }
+
    const block_signing_authority& pending_block_signing_authority() const {
-      return std::visit(overloaded{[](const assembled_block_dpos& bb) -> const block_signing_authority& {
-                                      return bb.pending_block_header_state.valid_block_signing_authority;
+      return std::visit(overloaded{[](const assembled_block_dpos& ab) -> const block_signing_authority& {
+                                      return ab.pending_block_header_state.valid_block_signing_authority;
                                    },
-                                   [](const assembled_block_if& bb) -> const block_signing_authority& {
-                                      return bb.producer_authority.authority;
+                                   [](const assembled_block_if& ab) -> const block_signing_authority& {
+                                      return ab.producer_authority.authority;
                                    }},
                         v);
    }
@@ -516,6 +532,18 @@ struct building_block {
                         v);
    }
 
+   const producer_authority_schedule& pending_producers() const {
+      return std::visit(overloaded{[](const building_block_dpos& bb) -> const producer_authority_schedule& {
+                                      if (bb.new_pending_producer_schedule)
+                                         return *bb.new_pending_producer_schedule;
+                                      return bb.pending_block_header_state.prev_pending_schedule.schedule;
+                                   },
+                                   [](const building_block_if& bb) -> const producer_authority_schedule& {
+                                      static producer_authority_schedule empty;
+                                      return empty; // [greg todo]
+                                   }},
+                        v);
+   }
 };
 
 
@@ -538,47 +566,50 @@ struct pending_state {
    controller::block_report       _block_report{};
 
    deque<transaction_metadata_ptr> extract_trx_metas() {
-      return std::visit([](auto& bb) { return bb.extract_trx_metas(); }, _block_stage);
+      return std::visit([](auto& stage) { return stage.extract_trx_metas(); }, _block_stage);
    }
 
    bool is_protocol_feature_activated(const digest_type& digest) const {
-      return std::visit([&](const auto& bb) { return bb.is_protocol_feature_activated(digest); }, _block_stage);
+      return std::visit([&](const auto& stage) { return stage.is_protocol_feature_activated(digest); }, _block_stage);
    }
 
    block_timestamp_type timestamp() const {
-      return std::visit([](const auto& bb) { return bb.timestamp(); }, _block_stage);
+      return std::visit([](const auto& stage) { return stage.timestamp(); }, _block_stage);
    }
 
    uint32_t block_num() const {
-      return std::visit([](const auto& bb) { return bb.block_num(); }, _block_stage);
+      return std::visit([](const auto& stage) { return stage.block_num(); }, _block_stage);
    }
 
    account_name producer() const {
-      return std::visit([](const auto& bb) { return bb.producer(); }, _block_stage);
+      return std::visit([](const auto& stage) { return stage.producer(); }, _block_stage);
    }
 
    void push() {
       _db_session.push();
    }
 
+   bool is_dpos() const { return std::visit([](const auto& stage) { return stage.is_dpos(); }, _block_stage); }
+   
    const block_signing_authority& pending_block_signing_authority() const {
       return std::visit(
-         [](const auto& bb) -> const block_signing_authority& { return bb.pending_block_signing_authority(); },
+         [](const auto& stage) -> const block_signing_authority& { return stage.pending_block_signing_authority(); },
          _block_stage);
    }
 
    const producer_authority_schedule& active_producers() const {
       return std::visit(
-         [](const auto& bb) -> const producer_authority_schedule& { return bb.active_producers(); },
+         [](const auto& stage) -> const producer_authority_schedule& { return stage.active_producers(); },
          _block_stage);
    }
+   
 #if 0
    const producer_authority_schedule& pending_producers() const {
       return std::visit(
          overloaded{
             [](const building_block& bb) -> const producer_authority_schedule& { return bb.pending_producers(); },
-            [](const assembled_block& bb) -> const producer_authority_schedule& { return bb.pending_producers(); },
-            [](const completed_block& bb) -> const producer_authority_schedule& { return bb.pending_producers(); }},
+            [](const assembled_block& ab) -> const producer_authority_schedule& { return ab.pending_producers(); },
+            [](const completed_block& cb) -> const producer_authority_schedule& { return cb.pending_producers(); }},
          _block_stage);
    }
 #endif
@@ -3721,25 +3752,21 @@ const producer_authority_schedule& controller::active_producers()const {
 }
 
 const producer_authority_schedule& controller::pending_producers()const {
-   if( !(my->pending) )
-      return  my->head->pending_schedule.schedule;
+   if( !(my->pending) ) 
+      return  my->head->pending_schedule.schedule;    // [greg todo] implement pending_producers for IF mode
 
    if( std::holds_alternative<completed_block>(my->pending->_block_stage) )
-      return std::get<completed_block>(my->pending->_block_stage)._block_state->pending_schedule.schedule;
+      return std::get<completed_block>(my->pending->_block_stage).pending_producers();
 
    if( std::holds_alternative<assembled_block>(my->pending->_block_stage) ) {
-      const auto& new_prods_cache = std::get<assembled_block>(my->pending->_block_stage)._new_producer_authority_cache;
-      if( new_prods_cache ) {
-         return *new_prods_cache;
+      const auto& pp = std::get<assembled_block>(my->pending->_block_stage).pending_producers();
+      if( pp ) {
+         return *pp;
       }
    }
 
    const auto& bb = std::get<building_block>(my->pending->_block_stage);
-   const auto& npps = bb._header.new_pending_producer_schedule();
-   if( npps )
-      return *npps;
-
-   return bb._pending_block_header_state.prev_pending_schedule.schedule;
+   return bb.pending_producers();
 }
 
 std::optional<producer_authority_schedule> controller::proposed_producers()const {
diff --git a/libraries/chain/include/eosio/chain/block_header_state.hpp b/libraries/chain/include/eosio/chain/block_header_state.hpp
index 34545e51ab..2978af7dd4 100644
--- a/libraries/chain/include/eosio/chain/block_header_state.hpp
+++ b/libraries/chain/include/eosio/chain/block_header_state.hpp
@@ -67,9 +67,9 @@ struct block_header_state {
    flat_map<uint32_t, finalizer_policy_ptr> _finalizer_policies;
 
    digest_type           compute_finalizer_digest() const;
-   block_timestamp_type  timestamp() const;
-   account_name          producer() const;
-   block_id_type         previous() const;
+   block_timestamp_type  timestamp() const { return _header.timestamp; }
+   account_name          producer() const { return _header.producer; }
+   block_id_type         previous() const { return _header.previous; }
    uint32_t              block_num() const { return block_header::num_from_id(previous()) + 1; }
    
    block_header_state next(const block_header_state_input& data) const;
@@ -79,13 +79,11 @@ struct block_header_state {
       return !_core.last_qc_block_height || qc.block_height > *_core.last_qc_block_height;
    }
 
-   protocol_feature_activation_set_ptr  get_prev_activated_protocol_features() const;
+   protocol_feature_activation_set_ptr  get_prev_activated_protocol_features() const { return {}; } //  [greg todo] 
    flat_set<digest_type> get_activated_protocol_features() const { return _activated_protocol_features->protocol_features; }
-   uint32_t pending_irreversible_blocknum() const;
-   uint32_t irreversible_blocknum() const;
    detail::schedule_info prev_pending_schedule() const;
    uint32_t active_schedule_version() const;
-   std::optional<producer_authority_schedule>& new_pending_producer_schedule();
+   std::optional<producer_authority_schedule>& new_pending_producer_schedule() { static std::optional<producer_authority_schedule> x; return x; } //  [greg todo] 
    signed_block_header make_block_header(const checksum256_type& transaction_mroot,
                                          const checksum256_type& action_mroot,
                                          const std::optional<producer_authority_schedule>& new_producers,
diff --git a/libraries/chain/include/eosio/chain/block_state.hpp b/libraries/chain/include/eosio/chain/block_state.hpp
index 015db70fb2..56d164dbdf 100644
--- a/libraries/chain/include/eosio/chain/block_state.hpp
+++ b/libraries/chain/include/eosio/chain/block_state.hpp
@@ -14,7 +14,7 @@ struct block_state {
    pending_quorum_certificate pending_qc;             // where we accumulate votes we receive
    std::optional<valid_quorum_certificate> valid_qc;  // qc received from the network
 
-   deque<transaction_metadata_ptr>      extract_trxs_metas() const; // see impl in block_state_legacy.hpp
+   deque<transaction_metadata_ptr>      extract_trxs_metas() const { return {}; }; //  [greg todo] see impl in block_state_legacy.hpp
 };
 
 using block_state_ptr = std::shared_ptr<block_state>;
diff --git a/unittests/block_header_state_tests.cpp b/unittests/block_header_state_tests.cpp
index 6324fab7d6..c5053919b3 100644
--- a/unittests/block_header_state_tests.cpp
+++ b/unittests/block_header_state_tests.cpp
@@ -1,4 +1,5 @@
 #include <eosio/chain/block_header_state_legacy.hpp>
+#include <eosio/chain/block_header_state.hpp>
 
 #include <boost/test/unit_test.hpp>