# hello-world template
# ./hello/src/program/src
.
├── entrypoint.rs
├── error.rs
├── instruction.rs
├── lib.rs
├── processor.rs
└── schema
    ├── dummy.rs
    └── mod.rs

This is how Rust-based source code look likes

Entrypoint.rs

Every calls will be handled at the beginning right here. Due to the simple mission and standardized code, we rarely need to modify this file.

entrypoint_deprecated!(process_instruction);
​
fn process_instruction<'a>(
  program_id: &Pubkey,
  accounts: &'a [AccountInfo<'a>],
  instruction_data: &[u8],
) -> ProgramResult {
  if let Err(error) = Processor::process(program_id, accounts, instruction_data) {
    error.print::<AppError>();
    return Err(error);
  }
  Ok(())
}

This component is to pass program_is, accounts list, and instruction_data to Processor.rs as the code above has shown, which is all the thing it does.

Processor.rs

After taking serialized data from Entrypoint.rs, all computation will be executed in Processor.rs. You may remember that all the data is serialized. Therefore, to work on and then store the data, we have to define methods to "unpack" and "pack" them, which is the main purpose of Instruction.rs

let instruction = AppInstruction::unpack(instruction_data)?;

First, Processor.rs passes instruction_data to Instruction.rs to unpack it and then get parameters from the return.

match instruction {
      AppInstruction::SayHello { amount, toggle } => { ... }
}

Next, depend on the instruction type, Processor.rs will decide which function would be called to handle the data.

Finally, return Ok or Error as results.

Instruction.rs

On instruction data, this component will parse corresponding parameters. The first byte of the instruction data always represents the instruction code. For example in hello-world program, if the first byte is 0, then it should parse the parameters for sayHello function.

let (&tag, rest) = instruction.split_first().ok_or(AppError::InvalidInstruction)?;
Ok(match tag {
      0 => {
            ...
            Self::SayHello { ... }
      }
      _ => return Err(AppError::InvalidInstruction.into())
})

Error.rs

Another component in Solana Rust-based programs is Error.rs. This component is to defined errors and explanations of those errors. Other components can use Error.rs to throw a very detailed error without a lengthy coding. Because the logic of this file is quite simple, so we don't need an overkill document here 😱. The only thing developers must do is following the convention and create numerous errors of desire.

Schema

Recall that a Solana program did not has storage by itself. To store information, you need to do that on separate accounts, then leave account permission to the program. Because the rigid form of data, it must be fixed size, stored in these accounts, we may need several accounts to store different types of data. In Schema folder, we can easily define and manage all account structures by schemata.

For example, dummy.rs is a typical schema is a hello-world program.

pub struct Dummy {
  pub amount: u32,
  pub toggle: bool,
}

The Dummy struct has 2 fields namely amount and toggle that program uses to understand the serialized data.

​