diff --git a/cli/src/program.rs b/cli/src/program.rs
index 12530007e1a..dd284d9d9aa 100644
--- a/cli/src/program.rs
+++ b/cli/src/program.rs
@@ -169,9 +169,8 @@ pub enum ProgramCliCommand {
         use_lamports_unit: bool,
         bypass_warning: bool,
     },
-    ExtendProgramChecked {
+    ExtendProgram {
         program_pubkey: Pubkey,
-        authority_signer_index: SignerIndex,
         payer_signer_index: SignerIndex,
         additional_bytes: u32,
     },
@@ -645,16 +644,6 @@ impl ProgramSubCommands for App<'_, '_> {
                                      data account",
                                 ),
                         )
-                        .arg(
-                            Arg::with_name("authority")
-                                .long("authority")
-                                .value_name("AUTHORITY_SIGNER")
-                                .takes_value(true)
-                                .validator(is_valid_signer)
-                                .help(
-                                    "Upgrade authority [default: the default configured keypair]",
-                                ),
-                        )
                         .arg(
                             Arg::with_name("payer")
                                 .long("payer")
@@ -1008,15 +997,11 @@ pub fn parse_program_subcommand(
         ("extend", Some(matches)) => {
             let program_pubkey = pubkey_of(matches, "program_id").unwrap();
             let additional_bytes = value_of(matches, "additional_bytes").unwrap();
-
-            let (authority_signer, authority_pubkey) =
-                signer_of(matches, "authority", wallet_manager)?;
             let (payer_signer, payer_pubkey) = signer_of(matches, "payer", wallet_manager)?;
 
             let signer_info = default_signer.generate_unique_signers(
                 vec![
                     Some(default_signer.signer_from_path(matches, wallet_manager)?),
-                    authority_signer,
                     payer_signer,
                 ],
                 matches,
@@ -1024,9 +1009,8 @@ pub fn parse_program_subcommand(
             )?;
 
             CliCommandInfo {
-                command: CliCommand::Program(ProgramCliCommand::ExtendProgramChecked {
+                command: CliCommand::Program(ProgramCliCommand::ExtendProgram {
                     program_pubkey,
-                    authority_signer_index: signer_info.index_of(authority_pubkey).unwrap(),
                     payer_signer_index: signer_info.index_of(payer_pubkey).unwrap(),
                     additional_bytes,
                 }),
@@ -1237,9 +1221,8 @@ pub async fn process_program_subcommand(
             )
             .await
         }
-        ProgramCliCommand::ExtendProgramChecked {
+        ProgramCliCommand::ExtendProgram {
             program_pubkey,
-            authority_signer_index,
             payer_signer_index,
             additional_bytes,
         } => {
@@ -1247,7 +1230,6 @@ pub async fn process_program_subcommand(
                 &rpc_client,
                 config,
                 *program_pubkey,
-                *authority_signer_index,
                 *payer_signer_index,
                 *additional_bytes,
             )
@@ -2416,12 +2398,10 @@ async fn process_extend_program(
     rpc_client: &RpcClient,
     config: &CliConfig<'_>,
     program_pubkey: Pubkey,
-    authority_signer_index: SignerIndex,
     payer_signer_index: SignerIndex,
     additional_bytes: u32,
 ) -> ProcessResult {
     let fee_payer_pubkey = config.signers[0].pubkey();
-    let authority_signer = config.signers[authority_signer_index];
     let payer_signer = config.signers[payer_signer_index];
     let payer_pubkey = payer_signer.pubkey();
 
@@ -2468,41 +2448,19 @@ async fn process_extend_program(
         _ => Err(format!("Program {program_pubkey} is closed")),
     }?;
 
-    let upgrade_authority_address = upgrade_authority_address
+    upgrade_authority_address
         .ok_or_else(|| format!("Program {program_pubkey} is not upgradeable"))?;
 
-    if authority_signer.pubkey() != upgrade_authority_address {
-        return Err(format!(
-            "Upgrade authority {} does not match {}",
-            upgrade_authority_address,
-            authority_signer.pubkey(),
-        )
-        .into());
-    }
-
     let blockhash = rpc_client.get_latest_blockhash().await?;
-    let feature_set = fetch_feature_set(rpc_client).await?;
 
-    let instruction = if feature_set.snapshot().enable_extend_program_checked {
-        loader_v3_instruction::extend_program_checked(
-            &program_pubkey,
-            &upgrade_authority_address,
-            Some(&payer_pubkey),
-            additional_bytes,
-        )
-    } else {
-        loader_v3_instruction::extend_program(
-            &program_pubkey,
-            Some(&payer_pubkey),
-            additional_bytes,
-        )
-    };
+    let instruction = loader_v3_instruction::extend_program(
+        &program_pubkey,
+        Some(&payer_pubkey),
+        additional_bytes,
+    );
     let mut tx = Transaction::new_unsigned(Message::new(&[instruction], Some(&fee_payer_pubkey)));
 
-    tx.try_sign(
-        &[config.signers[0], authority_signer, payer_signer],
-        blockhash,
-    )?;
+    tx.try_sign(&[config.signers[0], payer_signer], blockhash)?;
     let result = rpc_client
         .send_and_confirm_transaction_with_spinner_and_config(
             &tx,
@@ -2972,8 +2930,7 @@ async fn extend_program_data_if_needed(
         _ => Err(format!("Program {program_id} is closed")),
     }?;
 
-    let upgrade_authority_address = upgrade_authority_address
-        .ok_or_else(|| format!("Program {program_id} is not upgradeable"))?;
+    upgrade_authority_address.ok_or_else(|| format!("Program {program_id} is not upgradeable"))?;
 
     let required_len = UpgradeableLoaderState::size_of_programdata(program_len);
     let max_permitted_data_length = usize::try_from(MAX_PERMITTED_DATA_LENGTH).unwrap();
@@ -2997,17 +2954,8 @@ async fn extend_program_data_if_needed(
     let additional_bytes =
         u32::try_from(additional_bytes).expect("`u32` is big enough to hold an account size");
 
-    let feature_set = fetch_feature_set(rpc_client).await?;
-    let instruction = if feature_set.snapshot().enable_extend_program_checked {
-        loader_v3_instruction::extend_program_checked(
-            program_id,
-            &upgrade_authority_address,
-            Some(fee_payer),
-            additional_bytes,
-        )
-    } else {
-        loader_v3_instruction::extend_program(program_id, Some(fee_payer), additional_bytes)
-    };
+    let instruction =
+        loader_v3_instruction::extend_program(program_id, Some(fee_payer), additional_bytes);
     initial_instructions.push(instruction);
 
     Ok(())
@@ -4449,9 +4397,8 @@ mod tests {
         assert_eq!(
             parse_command(&test_command, &default_signer, &mut None).unwrap(),
             CliCommandInfo {
-                command: CliCommand::Program(ProgramCliCommand::ExtendProgramChecked {
+                command: CliCommand::Program(ProgramCliCommand::ExtendProgram {
                     program_pubkey,
-                    authority_signer_index: 0,
                     payer_signer_index: 0,
                     additional_bytes
                 }),
@@ -4459,35 +4406,6 @@ mod tests {
             }
         );
 
-        // with authority
-        let authority_keypair = Keypair::new();
-        let authority_keypair_file = make_tmp_path("authority_keypair_file");
-        write_keypair_file(&authority_keypair, &authority_keypair_file).unwrap();
-        let test_command = test_commands.clone().get_matches_from(vec![
-            "test",
-            "program",
-            "extend",
-            &program_pubkey.to_string(),
-            &additional_bytes.to_string(),
-            "--authority",
-            &authority_keypair_file,
-        ]);
-        assert_eq!(
-            parse_command(&test_command, &default_signer, &mut None).unwrap(),
-            CliCommandInfo {
-                command: CliCommand::Program(ProgramCliCommand::ExtendProgramChecked {
-                    program_pubkey,
-                    authority_signer_index: 1,
-                    payer_signer_index: 0,
-                    additional_bytes
-                }),
-                signers: vec![
-                    Box::new(read_keypair_file(&keypair_file).unwrap()),
-                    Box::new(read_keypair_file(&authority_keypair_file).unwrap()),
-                ],
-            }
-        );
-
         // with payer
         let payer_keypair = Keypair::new();
         let payer_keypair_file = make_tmp_path("payer_keypair_file");
@@ -4504,9 +4422,8 @@ mod tests {
         assert_eq!(
             parse_command(&test_command, &default_signer, &mut None).unwrap(),
             CliCommandInfo {
-                command: CliCommand::Program(ProgramCliCommand::ExtendProgramChecked {
+                command: CliCommand::Program(ProgramCliCommand::ExtendProgram {
                     program_pubkey,
-                    authority_signer_index: 0,
                     payer_signer_index: 1,
                     additional_bytes
                 }),
@@ -4516,35 +4433,6 @@ mod tests {
                 ],
             }
         );
-
-        // with both authority and payer
-        let test_command = test_commands.clone().get_matches_from(vec![
-            "test",
-            "program",
-            "extend",
-            &program_pubkey.to_string(),
-            &additional_bytes.to_string(),
-            "--authority",
-            &authority_keypair_file,
-            "--payer",
-            &payer_keypair_file,
-        ]);
-        assert_eq!(
-            parse_command(&test_command, &default_signer, &mut None).unwrap(),
-            CliCommandInfo {
-                command: CliCommand::Program(ProgramCliCommand::ExtendProgramChecked {
-                    program_pubkey,
-                    authority_signer_index: 1,
-                    payer_signer_index: 2,
-                    additional_bytes
-                }),
-                signers: vec![
-                    Box::new(read_keypair_file(&keypair_file).unwrap()),
-                    Box::new(read_keypair_file(&authority_keypair_file).unwrap()),
-                    Box::new(read_keypair_file(&payer_keypair_file).unwrap()),
-                ],
-            }
-        );
     }
 
     #[tokio::test]
diff --git a/cli/tests/program.rs b/cli/tests/program.rs
index 657d7ae09ae..b2764685b2c 100644
--- a/cli/tests/program.rs
+++ b/cli/tests/program.rs
@@ -1,7 +1,7 @@
 #![allow(clippy::arithmetic_side_effects)]
 
 use {
-    agave_feature_set::enable_alt_bn128_syscall,
+    agave_feature_set::{enable_alt_bn128_syscall, enable_extend_program_checked},
     assert_matches::assert_matches,
     serde_json::Value,
     solana_account::{ReadableAccount, state_traits::StateMut},
@@ -59,7 +59,8 @@ fn test_validator_genesis(mint_keypair: &Keypair) -> TestValidatorGenesis {
         })
         .faucet_addr(Some(run_local_faucet_with_unique_port_for_tests(
             mint_keypair.insecure_clone(),
-        )));
+        )))
+        .deactivate_features(&[enable_extend_program_checked::id()]);
     genesis
 }
 
@@ -1516,10 +1517,9 @@ async fn test_cli_program_extend_program() {
     file.read_to_end(&mut new_program_data).unwrap();
     let new_max_len = new_program_data.len();
     let additional_bytes = (new_max_len - max_len) as u32;
-    config.signers = vec![&keypair, &upgrade_authority];
-    config.command = CliCommand::Program(ProgramCliCommand::ExtendProgramChecked {
+    config.signers = vec![&keypair];
+    config.command = CliCommand::Program(ProgramCliCommand::ExtendProgram {
         program_pubkey: program_keypair.pubkey(),
-        authority_signer_index: 1,
         payer_signer_index: 0,
         additional_bytes: additional_bytes - 1,
     });
@@ -1571,10 +1571,9 @@ async fn test_cli_program_extend_program() {
     wait_n_slots(&rpc_client, 1).await;
 
     // Extend 1 last byte
-    config.signers = vec![&keypair, &upgrade_authority];
-    config.command = CliCommand::Program(ProgramCliCommand::ExtendProgramChecked {
+    config.signers = vec![&keypair];
+    config.command = CliCommand::Program(ProgramCliCommand::ExtendProgram {
         program_pubkey: program_keypair.pubkey(),
-        authority_signer_index: 1,
         payer_signer_index: 0,
         additional_bytes: 1,
     });
@@ -1619,11 +1618,10 @@ async fn test_cli_program_extend_program() {
     let programdata_account = rpc_client.get_account(&programdata_pubkey).await.unwrap();
     let prev_len = programdata_account.data.len();
 
-    config.signers = vec![&keypair, &upgrade_authority, &rent_payer];
-    config.command = CliCommand::Program(ProgramCliCommand::ExtendProgramChecked {
+    config.signers = vec![&keypair, &rent_payer];
+    config.command = CliCommand::Program(ProgramCliCommand::ExtendProgram {
         program_pubkey: program_keypair.pubkey(),
-        authority_signer_index: 1,
-        payer_signer_index: 2,
+        payer_signer_index: 1,
         additional_bytes: 1024,
     });
     process_command(&config).await.unwrap();
diff --git a/feature-set/src/lib.rs b/feature-set/src/lib.rs
index 20196bee200..1e1c0914def 100644
--- a/feature-set/src/lib.rs
+++ b/feature-set/src/lib.rs
@@ -52,7 +52,6 @@ pub struct FeatureSnapshot {
     pub deplete_cu_meter_on_vm_failure: bool,
     pub fix_alt_bn128_multiplication_input_length: bool,
     pub relax_intrabatch_account_locks: bool,
-    pub enable_extend_program_checked: bool,
     pub formalize_loaded_transaction_data_size: bool,
     pub alpenglow: bool,
     pub disable_zk_elgamal_proof_program: bool,
@@ -153,7 +152,6 @@ impl From<&AHashMap<Pubkey, u64>> for FeatureSnapshot {
                 &fix_alt_bn128_multiplication_input_length::ID,
             ),
             relax_intrabatch_account_locks: is_active(&relax_intrabatch_account_locks::ID),
-            enable_extend_program_checked: is_active(&enable_extend_program_checked::ID),
             formalize_loaded_transaction_data_size: is_active(
                 &formalize_loaded_transaction_data_size::ID,
             ),
@@ -339,7 +337,6 @@ impl FeatureSet {
             fix_alt_bn128_multiplication_input_length: snapshot
                 .fix_alt_bn128_multiplication_input_length,
             increase_tx_account_lock_limit: snapshot.increase_tx_account_lock_limit,
-            enable_extend_program_checked: snapshot.enable_extend_program_checked,
             formalize_loaded_transaction_data_size: snapshot.formalize_loaded_transaction_data_size,
             disable_zk_elgamal_proof_program: snapshot.disable_zk_elgamal_proof_program,
             reenable_zk_elgamal_proof_program: snapshot.reenable_zk_elgamal_proof_program,
diff --git a/program-runtime/src/cpi.rs b/program-runtime/src/cpi.rs
index 1794b482e03..76210c3c562 100644
--- a/program-runtime/src/cpi.rs
+++ b/program-runtime/src/cpi.rs
@@ -188,12 +188,6 @@ fn check_authorized_program(
                     && bpf_loader_upgradeable::is_set_authority_checked_instruction(
                         instruction_data,
                     ))
-                || (invoke_context
-                    .get_feature_set()
-                    .enable_extend_program_checked
-                    && bpf_loader_upgradeable::is_extend_program_checked_instruction(
-                        instruction_data,
-                    ))
                 || bpf_loader_upgradeable::is_close_instruction(instruction_data)))
         || invoke_context.is_precompile(program_id)
     {
diff --git a/programs/bpf-loader-tests/tests/extend_program_ix.rs b/programs/bpf-loader-tests/tests/extend_program_ix.rs
index 692737fa8f2..674bf43a6f9 100644
--- a/programs/bpf-loader-tests/tests/extend_program_ix.rs
+++ b/programs/bpf-loader-tests/tests/extend_program_ix.rs
@@ -4,9 +4,7 @@ use {
     solana_account::{AccountSharedData, ReadableAccount, WritableAccount},
     solana_instruction::error::InstructionError,
     solana_keypair::Keypair,
-    solana_loader_v3_interface::{
-        instruction::extend_program_checked, state::UpgradeableLoaderState,
-    },
+    solana_loader_v3_interface::{instruction::extend_program, state::UpgradeableLoaderState},
     solana_program_test::*,
     solana_pubkey::Pubkey,
     solana_sdk_ids::bpf_loader_upgradeable::id,
@@ -59,14 +57,13 @@ async fn test_extend_program() {
     let recent_blockhash = context.last_blockhash;
     const ADDITIONAL_BYTES: u32 = 42;
     let transaction = Transaction::new_signed_with_payer(
-        &[extend_program_checked(
+        &[extend_program(
             &program_address,
-            &upgrade_authority.pubkey(),
             Some(&payer.pubkey()),
             ADDITIONAL_BYTES,
         )],
         Some(&payer.pubkey()),
-        &[payer, &upgrade_authority],
+        &[payer],
         recent_blockhash,
     );
 
@@ -120,14 +117,13 @@ async fn test_failed_extend_twice_in_same_slot() {
     let recent_blockhash = context.last_blockhash;
     const ADDITIONAL_BYTES: u32 = 42;
     let transaction = Transaction::new_signed_with_payer(
-        &[extend_program_checked(
+        &[extend_program(
             &program_address,
-            &upgrade_authority.pubkey(),
             Some(&payer.pubkey()),
             ADDITIONAL_BYTES,
         )],
         Some(&payer.pubkey()),
-        &[payer, &upgrade_authority],
+        &[payer],
         recent_blockhash,
     );
 
@@ -148,68 +144,8 @@ async fn test_failed_extend_twice_in_same_slot() {
         .unwrap();
     // Extending the program in the same slot should fail
     let transaction = Transaction::new_signed_with_payer(
-        &[extend_program_checked(
-            &program_address,
-            &upgrade_authority.pubkey(),
-            Some(&payer.pubkey()),
-            ADDITIONAL_BYTES,
-        )],
-        Some(&payer.pubkey()),
-        &[payer, &upgrade_authority],
-        recent_blockhash,
-    );
-
-    assert_matches!(
-        client
-            .process_transaction(transaction)
-            .await
-            .unwrap_err()
-            .unwrap(),
-        TransactionError::InstructionError(0, InstructionError::InvalidArgument)
-    );
-}
-
-#[tokio::test]
-async fn test_failed_extend_upgrade_authority_did_not_sign() {
-    let mut context = setup_test_context().await;
-    let program_file = find_file("noop.so").expect("Failed to find the file");
-    let data = read_file(program_file);
-    let upgrade_authority = Keypair::new();
-
-    let program_address = Pubkey::new_unique();
-    let (programdata_address, _) = Pubkey::find_program_address(&[program_address.as_ref()], &id());
-    add_upgradeable_loader_account(
-        &mut context,
-        &program_address,
-        &UpgradeableLoaderState::Program {
-            programdata_address,
-        },
-        UpgradeableLoaderState::size_of_program(),
-        |_| {},
-    )
-    .await;
-    let programdata_data_offset = UpgradeableLoaderState::size_of_programdata_metadata();
-    let program_data_len = data.len() + programdata_data_offset;
-    add_upgradeable_loader_account(
-        &mut context,
-        &programdata_address,
-        &UpgradeableLoaderState::ProgramData {
-            slot: 0,
-            upgrade_authority_address: Some(upgrade_authority.pubkey()),
-        },
-        program_data_len,
-        |account| account.data_as_mut_slice()[programdata_data_offset..].copy_from_slice(&data),
-    )
-    .await;
-
-    let client = &mut context.banks_client;
-    let payer = &context.payer;
-    let recent_blockhash = context.last_blockhash;
-    const ADDITIONAL_BYTES: u32 = 42;
-    let transaction = Transaction::new_signed_with_payer(
-        &[extend_program_checked(
+        &[extend_program(
             &program_address,
-            &payer.pubkey(),
             Some(&payer.pubkey()),
             ADDITIONAL_BYTES,
         )],
@@ -224,30 +160,7 @@ async fn test_failed_extend_upgrade_authority_did_not_sign() {
             .await
             .unwrap_err()
             .unwrap(),
-        TransactionError::InstructionError(0, InstructionError::IncorrectAuthority)
-    );
-
-    let mut ix = extend_program_checked(
-        &program_address,
-        &upgrade_authority.pubkey(),
-        Some(&payer.pubkey()),
-        ADDITIONAL_BYTES,
-    );
-    ix.accounts[2].is_signer = false;
-    let transaction = Transaction::new_signed_with_payer(
-        &[ix],
-        Some(&payer.pubkey()),
-        &[payer],
-        recent_blockhash,
-    );
-
-    assert_matches!(
-        client
-            .process_transaction(transaction)
-            .await
-            .unwrap_err()
-            .unwrap(),
-        TransactionError::InstructionError(0, InstructionError::MissingRequiredSignature)
+        TransactionError::InstructionError(0, InstructionError::InvalidArgument)
     );
 }
 
@@ -282,7 +195,7 @@ async fn test_extend_program_not_upgradeable() {
     let payer_address = context.payer.pubkey();
     assert_ix_error(
         &mut context,
-        extend_program_checked(&program_address, &payer_address, Some(&payer_address), 42),
+        extend_program(&program_address, Some(&payer_address), 42),
         None,
         InstructionError::Immutable,
         "should fail because the program data account isn't upgradeable",
@@ -322,13 +235,8 @@ async fn test_extend_program_by_zero_bytes() {
     let payer_address = context.payer.pubkey();
     assert_ix_error(
         &mut context,
-        extend_program_checked(
-            &program_address,
-            &upgrade_authority.pubkey(),
-            Some(&payer_address),
-            0,
-        ),
-        Some(&upgrade_authority),
+        extend_program(&program_address, Some(&payer_address), 0),
+        None,
         InstructionError::InvalidInstructionData,
         "should fail because the program data account must be extended by more than 0 bytes",
     )
@@ -367,13 +275,8 @@ async fn test_extend_program_past_max_size() {
     let payer_address = context.payer.pubkey();
     assert_ix_error(
         &mut context,
-        extend_program_checked(
-            &program_address,
-            &upgrade_authority.pubkey(),
-            Some(&payer_address),
-            1,
-        ),
-        Some(&upgrade_authority),
+        extend_program(&program_address, Some(&payer_address), 1),
+        None,
         InstructionError::InvalidRealloc,
         "should fail because the program data account cannot be extended past the max data size",
     )
@@ -430,9 +333,8 @@ async fn test_extend_program_with_invalid_payer() {
 
     assert_ix_error(
         &mut context,
-        extend_program_checked(
+        extend_program(
             &program_address,
-            &upgrade_authority_address,
             Some(&payer_with_insufficient_funds.pubkey()),
             1024,
         ),
@@ -444,9 +346,8 @@ async fn test_extend_program_with_invalid_payer() {
 
     assert_ix_error(
         &mut context,
-        extend_program_checked(
+        extend_program(
             &program_address,
-            &upgrade_authority_address,
             Some(&payer_with_invalid_owner.pubkey()),
             1,
         ),
@@ -456,9 +357,8 @@ async fn test_extend_program_with_invalid_payer() {
     )
     .await;
 
-    let mut ix = extend_program_checked(
+    let mut ix = extend_program(
         &program_address,
-        &upgrade_authority_address,
         Some(&payer_with_sufficient_funds.pubkey()),
         1,
     );
@@ -520,8 +420,8 @@ async fn test_extend_program_without_payer() {
 
     assert_ix_error(
         &mut context,
-        extend_program_checked(&program_address, &upgrade_authority.pubkey(), None, 1024),
-        Some(&upgrade_authority),
+        extend_program(&program_address, None, 1024),
+        None,
         InstructionError::MissingAccount,
         "should fail because program data has insufficient funds to cover rent",
     )
@@ -543,15 +443,10 @@ async fn test_extend_program_without_payer() {
                 &programdata_address,
                 min_balance_increase_for_extend,
             ),
-            extend_program_checked(
-                &program_address,
-                &upgrade_authority.pubkey(),
-                None,
-                ADDITIONAL_BYTES,
-            ),
+            extend_program(&program_address, None, ADDITIONAL_BYTES),
         ],
         Some(&payer.pubkey()),
-        &[payer, &upgrade_authority],
+        &[payer],
         recent_blockhash,
     );
 
@@ -598,12 +493,7 @@ async fn test_extend_program_with_invalid_system_program() {
     .await;
 
     let payer_address = context.payer.pubkey();
-    let mut ix = extend_program_checked(
-        &program_address,
-        &upgrade_authority.pubkey(),
-        Some(&payer_address),
-        1,
-    );
+    let mut ix = extend_program(&program_address, Some(&payer_address), 1);
 
     // Change system program to an invalid key
     {
@@ -618,7 +508,7 @@ async fn test_extend_program_with_invalid_system_program() {
     assert_ix_error(
         &mut context,
         ix,
-        Some(&upgrade_authority),
+        None,
         InstructionError::MissingAccount,
         "should fail because the system program is missing",
     )
@@ -657,12 +547,7 @@ async fn test_extend_program_with_mismatch_program_data() {
     )
     .await;
 
-    let mut ix = extend_program_checked(
-        &program_address,
-        &upgrade_authority.pubkey(),
-        Some(&payer_address),
-        1,
-    );
+    let mut ix = extend_program(&program_address, Some(&payer_address), 1);
 
     // Replace ProgramData account meta with invalid account
     {
@@ -677,7 +562,7 @@ async fn test_extend_program_with_mismatch_program_data() {
     assert_ix_error(
         &mut context,
         ix,
-        Some(&upgrade_authority),
+        None,
         InstructionError::InvalidArgument,
         "should fail because the program data account doesn't match the program",
     )
@@ -714,12 +599,7 @@ async fn test_extend_program_with_readonly_program_data() {
     )
     .await;
 
-    let mut ix = extend_program_checked(
-        &program_address,
-        &upgrade_authority.pubkey(),
-        Some(&payer_address),
-        1,
-    );
+    let mut ix = extend_program(&program_address, Some(&payer_address), 1);
 
     // Demote ProgramData account meta to read-only
     {
@@ -734,7 +614,7 @@ async fn test_extend_program_with_readonly_program_data() {
     assert_ix_error(
         &mut context,
         ix,
-        Some(&upgrade_authority),
+        None,
         InstructionError::InvalidArgument,
         "should fail because the program data account is not writable",
     )
@@ -745,7 +625,6 @@ async fn test_extend_program_with_readonly_program_data() {
 async fn test_extend_program_with_invalid_program_data_state() {
     let mut context = setup_test_context().await;
     let payer_address = context.payer.pubkey();
-    let upgrade_authority = Keypair::new();
 
     let program_address = Pubkey::new_unique();
     let (programdata_address, _) = Pubkey::find_program_address(&[program_address.as_ref()], &id());
@@ -772,13 +651,8 @@ async fn test_extend_program_with_invalid_program_data_state() {
 
     assert_ix_error(
         &mut context,
-        extend_program_checked(
-            &program_address,
-            &upgrade_authority.pubkey(),
-            Some(&payer_address),
-            1024,
-        ),
-        Some(&upgrade_authority),
+        extend_program(&program_address, Some(&payer_address), 1024),
+        None,
         InstructionError::InvalidAccountData,
         "should fail because the program data account state isn't valid",
     )
@@ -818,7 +692,7 @@ async fn test_extend_program_with_invalid_program_data_owner() {
 
     assert_ix_error(
         &mut context,
-        extend_program_checked(&program_address, &payer_address, Some(&payer_address), 1024),
+        extend_program(&program_address, Some(&payer_address), 1024),
         None,
         InstructionError::InvalidAccountOwner,
         "should fail because the program data account owner isn't valid",
@@ -856,12 +730,7 @@ async fn test_extend_program_with_readonly_program() {
     )
     .await;
 
-    let mut ix = extend_program_checked(
-        &program_address,
-        &upgrade_authority.pubkey(),
-        Some(&payer_address),
-        1,
-    );
+    let mut ix = extend_program(&program_address, Some(&payer_address), 1);
 
     // Demote Program account meta to read-only
     {
@@ -876,7 +745,7 @@ async fn test_extend_program_with_readonly_program() {
     assert_ix_error(
         &mut context,
         ix,
-        Some(&upgrade_authority),
+        None,
         InstructionError::InvalidArgument,
         "should fail because the program account is not writable",
     )
@@ -916,13 +785,8 @@ async fn test_extend_program_with_invalid_program_owner() {
 
     assert_ix_error(
         &mut context,
-        extend_program_checked(
-            &program_address,
-            &upgrade_authority.pubkey(),
-            Some(&payer_address),
-            1024,
-        ),
-        Some(&upgrade_authority),
+        extend_program(&program_address, Some(&payer_address), 1024),
+        None,
         InstructionError::InvalidAccountOwner,
         "should fail because the program account owner isn't valid",
     )
@@ -962,13 +826,8 @@ async fn test_extend_program_with_invalid_program_state() {
 
     assert_ix_error(
         &mut context,
-        extend_program_checked(
-            &program_address,
-            &upgrade_authority.pubkey(),
-            Some(&payer_address),
-            1024,
-        ),
-        Some(&upgrade_authority),
+        extend_program(&program_address, Some(&payer_address), 1024),
+        None,
         InstructionError::InvalidAccountData,
         "should fail because the program account state isn't valid",
     )
diff --git a/programs/bpf_loader/src/lib.rs b/programs/bpf_loader/src/lib.rs
index fc5b0f5493a..c4e040e4a95 100644
--- a/programs/bpf_loader/src/lib.rs
+++ b/programs/bpf_loader/src/lib.rs
@@ -756,26 +756,12 @@ fn process_loader_upgradeable_instruction(
             }
         }
         UpgradeableLoaderInstruction::ExtendProgram { additional_bytes } => {
-            if invoke_context
-                .get_feature_set()
-                .enable_extend_program_checked
-            {
-                ic_logger_msg!(
-                    log_collector,
-                    "ExtendProgram was superseded by ExtendProgramChecked"
-                );
-                return Err(InstructionError::InvalidInstructionData);
-            }
             common_extend_program(invoke_context, additional_bytes, false)?;
         }
-        UpgradeableLoaderInstruction::ExtendProgramChecked { additional_bytes } => {
-            if !invoke_context
-                .get_feature_set()
-                .enable_extend_program_checked
-            {
-                return Err(InstructionError::InvalidInstructionData);
-            }
-            common_extend_program(invoke_context, additional_bytes, true)?;
+        UpgradeableLoaderInstruction::ExtendProgramChecked { .. } => {
+            // ExtendProgramChecked has been removed.
+            // This variant will be removed from the next interface release.
+            return Err(InstructionError::InvalidInstructionData);
         }
         UpgradeableLoaderInstruction::Migrate => {
             // Loader V4 has been removed.
diff --git a/svm-feature-set/src/lib.rs b/svm-feature-set/src/lib.rs
index 797ecfedb4e..9a012022248 100644
--- a/svm-feature-set/src/lib.rs
+++ b/svm-feature-set/src/lib.rs
@@ -31,7 +31,6 @@ pub struct SVMFeatureSet {
     pub simplify_alt_bn128_syscall_error_codes: bool,
     pub fix_alt_bn128_multiplication_input_length: bool,
     pub increase_tx_account_lock_limit: bool,
-    pub enable_extend_program_checked: bool,
     pub formalize_loaded_transaction_data_size: bool,
     pub disable_zk_elgamal_proof_program: bool,
     pub reenable_zk_elgamal_proof_program: bool,
@@ -85,7 +84,6 @@ impl SVMFeatureSet {
             simplify_alt_bn128_syscall_error_codes: true,
             fix_alt_bn128_multiplication_input_length: true,
             increase_tx_account_lock_limit: true,
-            enable_extend_program_checked: true,
             formalize_loaded_transaction_data_size: true,
             disable_zk_elgamal_proof_program: true,
             reenable_zk_elgamal_proof_program: true,