Create system account instead of PDA

Author: Nitish-bot

basics/create-account/steel/api/src/consts.rs

@@ -1,6 +1,6 @@
 use steel::*;
 
-/// Declare custom error enum 
+/// Declare custom error enum
 #[derive(Debug, Error, Clone, Copy, PartialEq, Eq, IntoPrimitive)]
 #[repr(u32)]
 pub enum CreateAccountError {

basics/create-account/steel/api/src/error.rs

@@ -1,11 +1,9 @@
-pub mod consts;
 pub mod error;
 pub mod instruction;
 pub mod sdk;
 pub mod state;
 
 pub mod prelude {
-    pub use crate::consts::*;
     pub use crate::error::*;
     pub use crate::instruction::*;
     pub use crate::sdk::*;

basics/create-account/steel/api/src/lib.rs

@@ -2,14 +2,12 @@ use steel::*;
 
 use crate::prelude::*;
 
-
-/// Creates an instruction to create an account
-pub fn initialize_account(signer: Pubkey) -> Instruction {
+pub fn initialize_account(signer: Pubkey, new_account_key: Pubkey) -> Instruction {
     Instruction {
         program_id: crate::ID,
         accounts: vec![
             AccountMeta::new(signer, true),
-            AccountMeta::new(new_account_pda().unwrap().0, false),
+            AccountMeta::new(new_account_key, false),
             AccountMeta::new_readonly(system_program::ID, false),
         ],
         data: InitializeAccount {}.to_bytes(),

basics/create-account/steel/api/src/sdk.rs

@@ -1,11 +1,5 @@
-use crate::consts::*;
 use steel::*;
 
-/// Fetch PDA of the account.
-pub fn new_account_pda() -> Option<(Pubkey, u8)> {
-    Pubkey::try_find_program_address(&[CREATE_ACCOUNT], &crate::id())
-}
-
 /// This enum is used to get a discriminator
 /// for the new account.
 #[repr(u8)]
@@ -14,11 +8,10 @@ pub enum CreateAccountDiscriminator {
     NewAccount = 0,
 }
 
-/// This empty struct represents the account type
+/// This empty struct represents the system account
+/// It contains no data and is used to create a new account
 #[repr(C)]
 #[derive(Clone, Copy, Debug, PartialEq, Pod, Zeroable)]
-pub struct NewAccount {
-    pub user_id: u8,
-}
+pub struct NewAccount {}
 
 account!(CreateAccountDiscriminator, NewAccount);

basics/create-account/steel/api/src/state.rs

@@ -10,9 +10,7 @@
     "build": "cargo build-sbf --manifest-path=./program/Cargo.toml --sbf-out-dir=./program/target/so",
     "deploy": "solana program deploy ./program/target/so/create_account_program.so"
   },
-  "keywords": [
-    "solana"
-  ],
+  "keywords": ["solana"],
   "author": "",
   "license": "MIT",
   "dependencies": {

basics/create-account/steel/package.json

@@ -1,36 +1,45 @@
 use create_account_api::prelude::*;
 use solana_program::msg;
+use steel::sysvar::rent::Rent;
 use steel::*;
 
 pub fn process_initialize(accounts: &[AccountInfo<'_>]) -> ProgramResult {
-
-    // Validate accounts
+    // Load accounts
     let [payer, new_account, system_program] = accounts else {
+        msg!("Not enough accounts provided");
         return Err(ProgramError::NotEnoughAccountKeys);
     };
-    payer.is_signer()?;
-    new_account
-        .is_empty()?
-        .is_writable()?
-        .has_seeds(&[CREATE_ACCOUNT, payer.key.as_ref()], &create_account_api::ID)?;
+
+    // Validate accounts
+    payer
+        .is_signer()
+        .map_err(|_| ProgramError::MissingRequiredSignature)?;
+
+    new_account.is_signer()?.is_empty()?.is_writable()?;
+
     system_program.is_program(&system_program::ID)?;
 
-    // Initialize the account.
-    create_account::<NewAccount>(
-        new_account,
-        system_program,
-        payer,
-        &create_account_api::ID,
-        &[CREATE_ACCOUNT, payer.key.as_ref()],
-    )?;
+    // The helper "create_account" will create an account
+    // owned by our program and not the system program
 
-    // Fetch the newly created account and give it
-    // an arbitrary user id
-    let created_account = new_account.as_account_mut::<NewAccount>(&create_account_api::ID)?;
-    created_account.user_id = 1;
+    // Calculate the minimum balance needed for the account
+    // Space required is the size of our NewAccount struct
+    let space_required = std::mem::size_of::<NewAccount>() as u64;
+    let lamports_required = (Rent::get()?).minimum_balance(space_required as usize);
+
+    // Create the account by invoking a create_account system instruction
+    solana_program::program::invoke(
+        &solana_program::system_instruction::create_account(
+            payer.key,
+            new_account.key,
+            lamports_required,
+            space_required,
+            &system_program::ID,
+        ),
+        &[payer.clone(), new_account.clone(), system_program.clone()],
+    )?;
 
     msg!("A new account has been created and initialized!");
-    msg!("Your user id is: {}", created_account.user_id);
 
     Ok(())
 }

basics/create-account/steel/program/src/initialize.rs

@@ -1,89 +1,46 @@
-import {
-  type Blockhash,
-  Keypair,
-  LAMPORTS_PER_SOL,
-  PublicKey,
-  SystemProgram,
-  Transaction,
-  TransactionInstruction,
-} from "@solana/web3.js";
-import { assert } from "chai";
-import { before, describe, it } from "mocha";
-import {
-  type BanksClient,
-  type ProgramTestContext,
-  start,
-} from "solana-bankrun";
+import { type Blockhash, Keypair, LAMPORTS_PER_SOL, PublicKey, SystemProgram, Transaction, TransactionInstruction } from '@solana/web3.js';
+import { assert } from 'chai';
+import { before, describe, it } from 'mocha';
+import { type BanksClient, type ProgramTestContext, start } from 'solana-bankrun';
 
-const PROGRAM_ID = new PublicKey(
-  "12rpZ18eGj7BeKvSFRZ45cni97HctTbKziBnW3MsH3NG",
-);
-const SEED = Buffer.from("createaccount"); // Convert to binary (bytes)
+const PROGRAM_ID = new PublicKey('12rpZ18eGj7BeKvSFRZ45cni97HctTbKziBnW3MsH3NG');
 
-describe("Create a system account", () => {
+const instructionDiscriminators = {
+  InitializeAccount: Buffer.from([0]),
+};
+
+describe('Create a system account', () => {
   let context: ProgramTestContext;
   let lastBlock: Blockhash;
   let client: BanksClient;
   let payer: Keypair;
 
   before(async () => {
-    context = await start(
-      [{ name: "create_account_program", programId: PROGRAM_ID }],
-      [],
-    );
+    context = await start([{ name: 'create_account_program', programId: PROGRAM_ID }], []);
     client = context.banksClient;
     payer = context.payer;
     lastBlock = context.lastBlockhash;
   });
 
-  it("Create the account via a cross program invocation", async () => {
-    const [PDA, _] = await PublicKey.findProgramAddressSync(
-      [SEED, payer.publicKey.toBuffer()],
-      PROGRAM_ID,
-    );
+  it('should create the account via a cross program invocation', async () => {
+    const newAccount = Keypair.generate();
 
     const ix = new TransactionInstruction({
       keys: [
         { pubkey: payer.publicKey, isSigner: true, isWritable: true },
-        { pubkey: PDA, isSigner: false, isWritable: true },
+        { pubkey: newAccount.publicKey, isSigner: true, isWritable: true },
         { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
       ],
       programId: PROGRAM_ID,
-      data: Buffer.from([0]),
-    });
-
-    const tx = new Transaction();
-    tx.recentBlockhash = lastBlock;
-    tx.add(ix).sign(payer);
-
-    // Process Transaction with all the instructions
-    const transaction = await client.processTransaction(tx);
-
-    assert(
-      transaction.logMessages[3].startsWith(
-        "Program log: A new account has been created and initialized!",
-      ),
-    );
-  });
-
-  it("Create the account via direct call to system program", async () => {
-    const newKeypair = Keypair.generate();
-
-    const ix = SystemProgram.createAccount({
-      fromPubkey: payer.publicKey,
-      newAccountPubkey: newKeypair.publicKey,
-      lamports: LAMPORTS_PER_SOL,
-      space: 0,
-      programId: SystemProgram.programId,
+      data: Buffer.concat([instructionDiscriminators.InitializeAccount]),
     });
 
     const tx = new Transaction();
     tx.recentBlockhash = lastBlock;
-    tx.add(ix).sign(payer, newKeypair);
+    tx.add(ix).sign(payer, newAccount);
 
+    // No other tests required besides confirming if the transaction is processed
+    // Since transactions are atomic, we can be certain the account was created
     await client.processTransaction(tx);
-    console.log(
-      `Account with public key ${newKeypair.publicKey} successfully created`,
-    );
   });
 });