fix: disable Chainlink for replicas

magicblock-accounts/src/scheduled_commits_processor.rs

@@ -5,15 +5,7 @@ use std::{
 
 use async_trait::async_trait;
 use magicblock_account_cloner::ChainlinkCloner;
-use magicblock_accounts_db::AccountsDb;
-use magicblock_chainlink::{
-    remote_account_provider::{
-        chain_rpc_client::ChainRpcClientImpl,
-        chain_updates_client::ChainUpdatesClient,
-    },
-    submux::SubMuxClient,
-    Chainlink,
-};
+use magicblock_chainlink::{ProdChainlink, ProdInnerChainlink};
 use magicblock_committor_service::{
     intent_execution_manager::BroadcastedIntentExecutionResult,
     intent_executor::ExecutionOutput, BaseIntentCommittor, CommittorService,
@@ -43,12 +35,9 @@ use crate::{
 const POISONED_MUTEX_MSG: &str =
     "Mutex of RemoteScheduledCommitsProcessor.intents_meta_map is poisoned";
 
-pub type ChainlinkImpl = Chainlink<
-    ChainRpcClientImpl,
-    SubMuxClient<ChainUpdatesClient>,
-    AccountsDb,
-    ChainlinkCloner,
->;
+pub type InnerChainlinkImpl = ProdInnerChainlink<ChainlinkCloner>;
+
+pub type ChainlinkImpl = ProdChainlink<ChainlinkCloner>;
 
 pub struct ScheduledCommitsProcessorImpl {
     committor: Arc<CommittorService>,

magicblock-aperture/src/requests/http/mod.rs

@@ -8,19 +8,20 @@ use hyper::{
     Request, Response,
 };
 use magicblock_accounts_db::traits::AccountsBank;
-use magicblock_core::link::transactions::{
-    SanitizeableTransaction, WithEncoded,
+use magicblock_core::{
+    coordination_mode::CoordinationMode,
+    link::transactions::{SanitizeableTransaction, WithEncoded},
 };
 use magicblock_metrics::metrics::{AccountFetchOrigin, ENSURE_ACCOUNTS_TIME};
 use prelude::JsonBody;
 use solana_account::{AccountSharedData, ReadableAccount};
-use solana_message::VersionedMessage;
 use solana_pubkey::Pubkey;
 use solana_transaction::{
     sanitized::SanitizedTransaction, versioned::VersionedTransaction,
 };
 use solana_transaction_status::UiTransactionEncoding;
 use tracing::*;
+use transaction_validation::validate_supported_transaction_shape;
 
 use super::RpcRequest;
 use crate::{
@@ -29,10 +30,6 @@ use crate::{
 
 pub(crate) type HandlerResult = RpcResult<Response<JsonBody>>;
 
-// Solana's builtin-program filters in compute-budget processing assume program
-// indices fit within a packet-bounded pubkey table (1232 / 32 = 38).
-const MAX_RUNTIME_PROGRAM_ID_INDEX_EXCLUSIVE: usize =
-    1232 / size_of::<Pubkey>();
 const SYSTEM_PROGRAM_ID: Pubkey =
     Pubkey::from_str_const("11111111111111111111111111111111");
 
@@ -123,13 +120,34 @@ impl HttpDispatcher {
             && account.owner() == &SYSTEM_PROGRAM_ID
     }
 
+    fn needs_onchain_interactions(&self) -> bool {
+        CoordinationMode::current().needs_onchain_interactions()
+    }
+
+    fn require_primary_rpc_method(
+        &self,
+        method: &'static str,
+    ) -> RpcResult<()> {
+        if self.needs_onchain_interactions() {
+            Ok(())
+        } else {
+            Err(RpcError::transaction_verification(format!(
+                "{method} is only available while validator is primary"
+            )))
+        }
+    }
+
     /// Fetches an account's data from the `AccountsDb` filling it in from chain
     /// as needed.
     #[instrument(skip_all)]
     async fn read_account_with_ensure(
         &self,
         pubkey: &Pubkey,
     ) -> Option<AccountSharedData> {
+        if !self.needs_onchain_interactions() {
+            return self.accountsdb.get_account(pubkey);
+        }
+
         let mark_empty_if_not_found = [*pubkey];
         let _timer = ENSURE_ACCOUNTS_TIME
             .with_label_values(&["account"])
@@ -158,6 +176,13 @@ impl HttpDispatcher {
         &self,
         pubkeys: &[Pubkey],
     ) -> Vec<Option<AccountSharedData>> {
+        if !self.needs_onchain_interactions() {
+            return pubkeys
+                .iter()
+                .map(|pubkey| self.accountsdb.get_account(pubkey))
+                .collect();
+        }
+
         trace!("Ensuring accounts");
         let _timer = ENSURE_ACCOUNTS_TIME
             .with_label_values(&["multi-account"])
@@ -246,6 +271,8 @@ impl HttpDispatcher {
         &self,
         transaction: &SanitizedTransaction,
     ) -> RpcResult<()> {
+        self.require_primary_rpc_method("transaction")?;
+
         let _timer = ENSURE_ACCOUNTS_TIME
             .with_label_values(&["transaction"])
             .start_timer();
@@ -271,30 +298,6 @@ impl HttpDispatcher {
     }
 }
 
-fn validate_supported_transaction_shape(
-    transaction: &VersionedTransaction,
-) -> RpcResult<()> {
-    if let VersionedMessage::V0(message) = &transaction.message {
-        if !message.address_table_lookups.is_empty() {
-            return Err(RpcError::transaction_verification(
-                "v0 transactions with address lookup tables are not supported",
-            ));
-        }
-    }
-
-    for instruction in transaction.message.instructions() {
-        let program_id_index = usize::from(instruction.program_id_index);
-        if program_id_index >= MAX_RUNTIME_PROGRAM_ID_INDEX_EXCLUSIVE {
-            return Err(RpcError::transaction_verification(format!(
-                "unsupported program id index {program_id_index}; max supported is {}",
-                MAX_RUNTIME_PROGRAM_ID_INDEX_EXCLUSIVE - 1
-            )));
-        }
-    }
-
-    Ok(())
-}
-
 /// A prelude module to provide common imports for all RPC handler modules.
 mod prelude {
     pub(super) use magicblock_core::{link::accounts::LockedAccount, Slot};
@@ -358,6 +361,7 @@ pub(crate) mod mocked;
 pub(crate) mod request_airdrop;
 pub(crate) mod send_transaction;
 pub(crate) mod simulate_transaction;
+mod transaction_validation;
 
 // Magic Router compatibility methods.
 pub(crate) mod get_delegation_status;

magicblock-aperture/src/requests/http/send_transaction.rs

@@ -19,6 +19,7 @@ impl HttpDispatcher {
         &self,
         request: &mut JsonRequest,
     ) -> HandlerResult {
+        self.require_primary_rpc_method("sendTransaction")?;
         let _timer = TRANSACTION_PROCESSING_TIME.start_timer();
         let (transaction_str, config) =
             parse_params!(request.params()?, String, RpcSendTransactionConfig);

magicblock-aperture/src/requests/http/simulate_transaction.rs

@@ -26,6 +26,8 @@ impl HttpDispatcher {
         &self,
         request: &mut JsonRequest,
     ) -> HandlerResult {
+        self.require_primary_rpc_method("simulateTransaction")?;
+
         let (transaction_str, config) = parse_params!(
             request.params()?,
             String,

magicblock-aperture/src/requests/http/transaction_validation.rs

@@ -0,0 +1,151 @@
+use std::mem::size_of;
+
+use solana_message::VersionedMessage;
+use solana_pubkey::Pubkey;
+use solana_transaction::versioned::VersionedTransaction;
+
+use crate::{error::RpcError, RpcResult};
+
+// Solana's builtin-program filters in compute-budget processing assume program
+// indices fit within a packet-bounded pubkey table (1232 / 32 = 38).
+const MAX_RUNTIME_PROGRAM_ID_INDEX_EXCLUSIVE: usize =
+    1232 / size_of::<Pubkey>();
+
+pub(super) fn validate_supported_transaction_shape(
+    transaction: &VersionedTransaction,
+) -> RpcResult<()> {
+    if let VersionedMessage::V0(message) = &transaction.message {
+        if !message.address_table_lookups.is_empty() {
+            return Err(RpcError::transaction_verification(
+                "v0 transactions with address lookup tables are not supported",
+            ));
+        }
+    }
+
+    for instruction in transaction.message.instructions() {
+        let program_id_index = usize::from(instruction.program_id_index);
+        if program_id_index >= MAX_RUNTIME_PROGRAM_ID_INDEX_EXCLUSIVE {
+            return Err(RpcError::transaction_verification(format!(
+                "unsupported program id index {program_id_index}; max supported is {}",
+                MAX_RUNTIME_PROGRAM_ID_INDEX_EXCLUSIVE - 1
+            )));
+        }
+    }
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use magicblock_core::link::blocks::BlockHash;
+    use solana_message::{
+        compiled_instruction::CompiledInstruction,
+        legacy::Message,
+        v0::{Message as V0Message, MessageAddressTableLookup},
+        MessageHeader, VersionedMessage,
+    };
+    use solana_pubkey::Pubkey;
+    use solana_signature::Signature;
+    use solana_transaction::versioned::VersionedTransaction;
+
+    use super::validate_supported_transaction_shape;
+
+    const SYSTEM_PROGRAM_ID: Pubkey =
+        Pubkey::from_str_const("11111111111111111111111111111111");
+    const COMPUTE_BUDGET_ID: Pubkey =
+        Pubkey::from_str_const("ComputeBudget111111111111111111111111111111");
+
+    #[test]
+    fn accepts_program_id_index_within_runtime_limit() {
+        let transaction = VersionedTransaction {
+            signatures: vec![Signature::default()],
+            message: VersionedMessage::Legacy(Message {
+                header: MessageHeader {
+                    num_required_signatures: 1,
+                    num_readonly_signed_accounts: 0,
+                    num_readonly_unsigned_accounts: 37,
+                },
+                account_keys: {
+                    let mut keys = vec![SYSTEM_PROGRAM_ID];
+                    keys.extend(std::iter::repeat_n(SYSTEM_PROGRAM_ID, 36));
+                    keys.push(COMPUTE_BUDGET_ID);
+                    keys
+                },
+                recent_blockhash: BlockHash::new_unique(),
+                instructions: vec![CompiledInstruction {
+                    program_id_index: 37,
+                    accounts: vec![],
+                    data: vec![],
+                }],
+            }),
+        };
+
+        validate_supported_transaction_shape(&transaction).unwrap();
+    }
+
+    #[test]
+    fn rejects_program_id_index_outside_runtime_limit() {
+        let transaction = VersionedTransaction {
+            signatures: vec![Signature::default()],
+            message: VersionedMessage::Legacy(Message {
+                header: MessageHeader {
+                    num_required_signatures: 1,
+                    num_readonly_signed_accounts: 0,
+                    num_readonly_unsigned_accounts: 38,
+                },
+                account_keys: {
+                    let mut keys = vec![SYSTEM_PROGRAM_ID];
+                    keys.extend(std::iter::repeat_n(SYSTEM_PROGRAM_ID, 37));
+                    keys.push(COMPUTE_BUDGET_ID);
+                    keys
+                },
+                recent_blockhash: BlockHash::new_unique(),
+                instructions: vec![CompiledInstruction {
+                    program_id_index: 38,
+                    accounts: vec![],
+                    data: vec![],
+                }],
+            }),
+        };
+
+        let error =
+            validate_supported_transaction_shape(&transaction).unwrap_err();
+        assert!(
+            error
+                .to_string()
+                .contains("unsupported program id index 38"),
+            "unexpected error: {error}"
+        );
+    }
+
+    #[test]
+    fn rejects_v0_transactions_with_address_lookup_tables() {
+        let transaction = VersionedTransaction {
+            signatures: vec![Signature::default()],
+            message: VersionedMessage::V0(V0Message {
+                header: MessageHeader {
+                    num_required_signatures: 1,
+                    num_readonly_signed_accounts: 0,
+                    num_readonly_unsigned_accounts: 1,
+                },
+                account_keys: vec![SYSTEM_PROGRAM_ID],
+                recent_blockhash: BlockHash::new_unique(),
+                instructions: vec![],
+                address_table_lookups: vec![MessageAddressTableLookup {
+                    account_key: Pubkey::new_unique(),
+                    writable_indexes: vec![0],
+                    readonly_indexes: vec![1],
+                }],
+            }),
+        };
+
+        let error =
+            validate_supported_transaction_shape(&transaction).unwrap_err();
+        assert!(
+            error.to_string().contains(
+                "v0 transactions with address lookup tables are not supported"
+            ),
+            "unexpected error: {error}"
+        );
+    }
+}

magicblock-aperture/src/state/mod.rs

@@ -4,26 +4,16 @@ use blocks::{BlocksCache, LastCachedBlock};
 use cache::ExpiringCache;
 use magicblock_account_cloner::ChainlinkCloner;
 use magicblock_accounts_db::AccountsDb;
-use magicblock_chainlink::{
-    remote_account_provider::{
-        chain_rpc_client::ChainRpcClientImpl,
-        chain_updates_client::ChainUpdatesClient,
-    },
-    submux::SubMuxClient,
-    Chainlink,
-};
+use magicblock_chainlink::{ProdChainlink, ProdInnerChainlink};
 use magicblock_ledger::Ledger;
 use solana_feature_set::FeatureSet;
 use solana_pubkey::Pubkey;
 use subscriptions::SubscriptionsDb;
 use transactions::TransactionsCache;
 
-pub type ChainlinkImpl = Chainlink<
-    ChainRpcClientImpl,
-    SubMuxClient<ChainUpdatesClient>,
-    AccountsDb,
-    ChainlinkCloner,
->;
+pub type InnerChainlinkImpl = ProdInnerChainlink<ChainlinkCloner>;
+
+pub type ChainlinkImpl = ProdChainlink<ChainlinkCloner>;
 
 /// A container for the shared, global state of the RPC service.
 ///

magicblock-aperture/src/tests.rs

@@ -24,7 +24,7 @@ use tokio_util::sync::CancellationToken;
 use crate::{
     encoder::{AccountEncoder, ProgramAccountEncoder, TransactionLogsEncoder},
     server::websocket::dispatch::WsConnectionChannel,
-    state::{ChainlinkImpl, SharedState},
+    state::{ChainlinkImpl, InnerChainlinkImpl, SharedState},
     utils::ProgramFilters,
     EventProcessor,
 };
@@ -42,8 +42,14 @@ fn ws_channel() -> (WsConnectionChannel, Receiver<Bytes>) {
 
 fn chainlink(accounts_db: &Arc<AccountsDb>) -> ChainlinkImpl {
     let cfg = ChainLinkConfig::default();
-    ChainlinkImpl::try_new(accounts_db, None, Pubkey::new_unique(), &cfg)
-        .expect("Failed to create Chainlink")
+    let real = InnerChainlinkImpl::try_new(
+        accounts_db,
+        None,
+        Pubkey::new_unique(),
+        &cfg,
+    )
+    .expect("Failed to create Chainlink");
+    ChainlinkImpl::enabled(real)
 }
 
 mod event_processor {