Add support for deprecated loader (#11946)

sdk/bpf/c/inc/deserialize_deprecated.h

@@ -0,0 +1,115 @@
+#pragma once
+/**
+ * @brief Solana bpf_loader_deprecated deserializer to used when deploying
+ * a program with `BPFLoader1111111111111111111111111111111111`
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * De-serializes the input parameters into usable types
+ *
+ * Use this function to deserialize the buffer passed to the program entrypoint
+ * into usable types.  This function does not perform copy deserialization,
+ * instead it populates the pointers and lengths in SolAccountInfo and data so
+ * that any modification to lamports or account data take place on the original
+ * buffer.  Doing so also eliminates the need to serialize back into the buffer
+ * at the end of the program.
+ *
+ * @param input Source buffer containing serialized input parameters
+ * @param params Pointer to a SolParameters structure
+ * @return Boolean true if successful.
+ */
+static bool sol_deserialize_deprecated(
+  const uint8_t *input,
+  SolParameters *params,
+  uint64_t ka_num
+) {
+  if (NULL == input || NULL == params) {
+    return false;
+  }
+  params->ka_num = *(uint64_t *) input;
+  input += sizeof(uint64_t);
+
+  for (int i = 0; i < params->ka_num; i++) {
+    uint8_t dup_info = input[0];
+    input += sizeof(uint8_t);
+
+    if (i >= ka_num) {
+      if (dup_info == UINT8_MAX) {
+        input += sizeof(uint8_t);
+        input += sizeof(uint8_t);
+        input += sizeof(SolPubkey);
+        input += sizeof(uint64_t);
+        input += *(uint64_t *) input;
+        input += sizeof(uint64_t);
+        input += sizeof(SolPubkey);
+        input += sizeof(uint8_t);
+        input += sizeof(uint64_t);
+      }
+      continue;
+    }
+    if (dup_info == UINT8_MAX) {
+      // is signer?
+      params->ka[i].is_signer = *(uint8_t *) input != 0;
+      input += sizeof(uint8_t);
+
+      // is writable?
+      params->ka[i].is_writable = *(uint8_t *) input != 0;
+      input += sizeof(uint8_t);
+
+      // key
+      params->ka[i].key = (SolPubkey *) input;
+      input += sizeof(SolPubkey);
+
+      // lamports
+      params->ka[i].lamports = (uint64_t *) input;
+      input += sizeof(uint64_t);
+
+      // account data
+      params->ka[i].data_len = *(uint64_t *) input;
+      input += sizeof(uint64_t);
+      params->ka[i].data = (uint8_t *) input;
+      input += params->ka[i].data_len;
+
+      // owner
+      params->ka[i].owner = (SolPubkey *) input;
+      input += sizeof(SolPubkey);
+
+      // executable?
+      params->ka[i].executable = *(uint8_t *) input;
+      input += sizeof(uint8_t);
+
+      // rent epoch
+      params->ka[i].rent_epoch = *(uint64_t *) input;
+      input += sizeof(uint64_t);
+    } else {
+      params->ka[i].is_signer = params->ka[dup_info].is_signer;
+      params->ka[i].key = params->ka[dup_info].key;
+      params->ka[i].lamports = params->ka[dup_info].lamports;
+      params->ka[i].data_len = params->ka[dup_info].data_len;
+      params->ka[i].data = params->ka[dup_info].data;
+      params->ka[i].owner = params->ka[dup_info].owner;
+      params->ka[i].executable = params->ka[dup_info].executable;
+      params->ka[i].rent_epoch = params->ka[dup_info].rent_epoch;
+    }
+  }
+
+  params->data_len = *(uint64_t *) input;
+  input += sizeof(uint64_t);
+  params->data = input;
+  input += params->data_len;
+
+  params->program_id = (SolPubkey *) input;
+  input += sizeof(SolPubkey);
+
+  return true;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+/**@}*/

sdk/src/bpf_loader.rs

@@ -1 +1,17 @@
+//! @brief The latest Solana BPF loader.
+//!
+//! The BPF loader is responsible for loading, finalizing, and executing BPF
+//! programs.  Not all networks may support the latest loader.  You can use the
+//! command-line tools to check if this version of the loader is supported by
+//! requesting the account info for the public key below.
+//!
+//! The program format may change between loaders, and it is crucial to build
+//! your program against the proper entrypoint semantics.  All programs being
+//! deployed to this BPF loader must build against the latest entrypoint version
+//! located in `entrypoint.rs`.
+//!
+//! Note: Programs built for older loaders must use a matching entrypoint
+//! version.  An example is `bpf_loader_deprecated.rs` which requires
+//! `entrypoint_deprecated.rs`.
+
 crate::declare_id!("BPFLoader2111111111111111111111111111111111");

sdk/src/bpf_loader_deprecated.rs

@@ -1 +1,14 @@
+//! @brief The original and now deprecated Solana BPF loader.
+//!
+//! The BPF loader is responsible for loading, finalizing, and executing BPF
+//! programs.
+//!
+//! This loader is deprecated, and it is strongly encouraged to build for and
+//! deploy to the latest BPF loader.  For more information see `bpf_loader.rs`
+//!
+//! The program format may change between loaders, and it is crucial to build
+//! your program against the proper entrypoint semantics.  All programs being
+//! deployed to this BPF loader must build against the deprecated entrypoint
+//! version located in `entrypoint_deprecated.rs`.
+
 crate::declare_id!("BPFLoader1111111111111111111111111111111111");

sdk/src/entrypoint.rs

@@ -1,4 +1,5 @@
-//! @brief Solana Rust-based BPF program entry point
+//! @brief Solana Rust-based BPF program entry point supported by the latest
+//! BPFLoader.  For more information see './bpf_loader.rs'
 
 extern crate alloc;
 use crate::{account_info::AccountInfo, program_error::ProgramError, pubkey::Pubkey};

sdk/src/entrypoint_deprecated.rs

@@ -0,0 +1,138 @@
+//! @brief Solana Rust-based BPF program entry point supported by the original
+//!  and now deprecated BPFLoader.  For more information see
+//!  './bpf_loader_deprecated.rs'
+
+extern crate alloc;
+use crate::{account_info::AccountInfo, program_error::ProgramError, pubkey::Pubkey};
+use alloc::vec::Vec;
+use std::{
+    cell::RefCell,
+    mem::size_of,
+    rc::Rc,
+    // Hide Result from bindgen gets confused about generics in non-generic type declarations
+    result::Result as ResultGeneric,
+    slice::{from_raw_parts, from_raw_parts_mut},
+};
+
+pub type ProgramResult = ResultGeneric<(), ProgramError>;
+
+/// User implemented function to process an instruction
+///
+/// program_id: Program ID of the currently executing program
+/// accounts: Accounts passed as part of the instruction
+/// instruction_data: Instruction data
+pub type ProcessInstruction =
+    fn(program_id: &Pubkey, accounts: &[AccountInfo], instruction_data: &[u8]) -> ProgramResult;
+
+/// Programs indicate success with a return value of 0
+pub const SUCCESS: u64 = 0;
+
+/// Declare the entry point of the program.
+///
+/// Deserialize the program input arguments and call
+/// the user defined `process_instruction` function.
+/// Users must call this macro otherwise an entry point for
+/// their program will not be created.
+#[macro_export]
+macro_rules! entrypoint_deprecated {
+    ($process_instruction:ident) => {
+        /// # Safety
+        #[cfg(not(feature = "skip-no-mangle"))]
+        #[no_mangle]
+        pub unsafe extern "C" fn entrypoint(input: *mut u8) -> u64 {
+            let (program_id, accounts, instruction_data) =
+                unsafe { $crate::entrypoint_deprecated::deserialize(input) };
+            match $process_instruction(&program_id, &accounts, &instruction_data) {
+                Ok(()) => $crate::entrypoint_deprecated::SUCCESS,
+                Err(error) => error.into(),
+            }
+        }
+    };
+}
+
+/// Deserialize the input arguments
+///
+/// # Safety
+#[allow(clippy::type_complexity)]
+pub unsafe fn deserialize<'a>(input: *mut u8) -> (&'a Pubkey, Vec<AccountInfo<'a>>, &'a [u8]) {
+    let mut offset: usize = 0;
+
+    // Number of accounts present
+
+    #[allow(clippy::cast_ptr_alignment)]
+    let num_accounts = *(input.add(offset) as *const u64) as usize;
+    offset += size_of::<u64>();
+
+    // Account Infos
+
+    let mut accounts = Vec::with_capacity(num_accounts);
+    for _ in 0..num_accounts {
+        let dup_info = *(input.add(offset) as *const u8);
+        offset += size_of::<u8>();
+        if dup_info == std::u8::MAX {
+            #[allow(clippy::cast_ptr_alignment)]
+            let is_signer = *(input.add(offset) as *const u8) != 0;
+            offset += size_of::<u8>();
+
+            #[allow(clippy::cast_ptr_alignment)]
+            let is_writable = *(input.add(offset) as *const u8) != 0;
+            offset += size_of::<u8>();
+
+            let key: &Pubkey = &*(input.add(offset) as *const Pubkey);
+            offset += size_of::<Pubkey>();
+
+            #[allow(clippy::cast_ptr_alignment)]
+            let lamports = Rc::new(RefCell::new(&mut *(input.add(offset) as *mut u64)));
+            offset += size_of::<u64>();
+
+            #[allow(clippy::cast_ptr_alignment)]
+            let data_len = *(input.add(offset) as *const u64) as usize;
+            offset += size_of::<u64>();
+
+            let data = Rc::new(RefCell::new({
+                from_raw_parts_mut(input.add(offset), data_len)
+            }));
+            offset += data_len;
+
+            let owner: &Pubkey = &*(input.add(offset) as *const Pubkey);
+            offset += size_of::<Pubkey>();
+
+            #[allow(clippy::cast_ptr_alignment)]
+            let executable = *(input.add(offset) as *const u8) != 0;
+            offset += size_of::<u8>();
+
+            #[allow(clippy::cast_ptr_alignment)]
+            let rent_epoch = *(input.add(offset) as *const u64);
+            offset += size_of::<u64>();
+
+            accounts.push(AccountInfo {
+                is_signer,
+                is_writable,
+                key,
+                lamports,
+                data,
+                owner,
+                executable,
+                rent_epoch,
+            });
+        } else {
+            // Duplicate account, clone the original
+            accounts.push(accounts[dup_info as usize].clone());
+        }
+    }
+
+    // Instruction data
+
+    #[allow(clippy::cast_ptr_alignment)]
+    let instruction_data_len = *(input.add(offset) as *const u64) as usize;
+    offset += size_of::<u64>();
+
+    let instruction_data = { from_raw_parts(input.add(offset), instruction_data_len) };
+    offset += instruction_data_len;
+
+    // Program Id
+
+    let program_id: &Pubkey = &*(input.add(offset) as *const Pubkey);
+
+    (program_id, accounts, instruction_data)
+}

sdk/src/lib.rs

@@ -75,6 +75,7 @@ pub use solana_sdk_macro::respan;
 // On-chain program specific modules
 pub mod account_info;
 pub mod entrypoint;
+pub mod entrypoint_deprecated;
 pub mod log;
 pub mod program;
 pub mod program_error;