feat: Implement RegisterOperator

Author: snawaz

dlp-api/src/v2/args/mod.rs

@@ -1,3 +1,5 @@
 mod init_protocol_config;
+mod register_operator;
 
 pub use init_protocol_config::*;
+pub use register_operator::*;

dlp-api/src/v2/args/register_operator.rs

@@ -0,0 +1,20 @@
+use wheels::{layout::Decodable, variable_offset_layout};
+
+use crate::solana_program::program_error::ProgramError;
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+#[variable_offset_layout(buffer_offset = unaligned)]
+pub struct RegisterOperatorArgs {
+    pub amount_lamports: u64,
+}
+
+impl RegisterOperatorArgs {
+    pub fn try_from_bytes(data: &[u8]) -> Result<Self, ProgramError> {
+        let view = <Self as Decodable>::decode(data)
+            .map_err(super::super::state::layout_error_to_program_error)?;
+
+        Ok(Self {
+            amount_lamports: view.amount_lamports(),
+        })
+    }
+}

dlp-api/src/v2/instruction.rs

@@ -7,6 +7,8 @@ use strum::IntoStaticStr;
 pub enum DlpV2Instruction {
     /// Creates the global v2 protocol config and verifier registry accounts.
     InitProtocolConfig = 100,
+    /// Registers one operator and deposits its initial stake.
+    RegisterOperator = 101,
 }
 
 impl DlpV2Instruction {

dlp-api/src/v2/instruction_builder/mod.rs

@@ -1,3 +1,5 @@
 mod init_protocol_config;
+mod register_operator;
 
 pub use init_protocol_config::*;
+pub use register_operator::*;

dlp-api/src/v2/instruction_builder/register_operator.rs

@@ -0,0 +1,40 @@
+use solana_program::{
+    instruction::{AccountMeta, Instruction},
+    pubkey::Pubkey,
+};
+use solana_sdk_ids::system_program;
+use wheels::layout::Encodable;
+
+use crate::{
+    compat::{Compatize, Modernize},
+    v2::{
+        pda::{operator_bond_pda, protocol_config_pda},
+        DlpV2Instruction, RegisterOperatorArgs,
+    },
+};
+
+/// Builds the instruction that registers one operator for v2 commitments.
+pub fn register_operator(
+    operator: Pubkey,
+    authority: Pubkey,
+    args: RegisterOperatorArgs,
+) -> Instruction {
+    Instruction {
+        program_id: crate::id().modernize(),
+        accounts: vec![
+            AccountMeta::new(operator, true),
+            AccountMeta::new_readonly(authority, true),
+            AccountMeta::new(
+                operator_bond_pda(&operator.compatize()).modernize(),
+                false,
+            ),
+            AccountMeta::new_readonly(protocol_config_pda().modernize(), false),
+            AccountMeta::new_readonly(system_program::id(), false),
+        ],
+        data: [
+            DlpV2Instruction::RegisterOperator.to_vec(),
+            args.encode().unwrap(),
+        ]
+        .concat(),
+    }
+}

dlp-api/src/v2/pda.rs

@@ -1,6 +1,7 @@
 use crate::compat::Pubkey;
 
 pub const PROTOCOL_CONFIG_SEED: &[u8] = b"protocol-config";
+pub const OPERATOR_BOND_SEED: &[u8] = b"operator-bond";
 pub const VERIFIER_REGISTRY_SEED: &[u8] = b"verifier-registry";
 
 pub fn protocol_config_pda() -> Pubkey {
@@ -10,3 +11,11 @@ pub fn protocol_config_pda() -> Pubkey {
 pub fn verifier_registry_pda() -> Pubkey {
     Pubkey::find_program_address(&[VERIFIER_REGISTRY_SEED], &crate::id()).0
 }
+
+pub fn operator_bond_pda(operator: &Pubkey) -> Pubkey {
+    Pubkey::find_program_address(
+        &[OPERATOR_BOND_SEED, operator.as_ref()],
+        &crate::id(),
+    )
+    .0
+}

dlp-api/src/v2/state/mod.rs

@@ -1,7 +1,9 @@
+mod operator_bond;
 mod protocol_config;
 mod utils;
 mod verifier_registry;
 
+pub use operator_bond::*;
 pub use protocol_config::*;
 pub use utils::layout_error_to_program_error;
 pub use verifier_registry::*;

dlp-api/src/v2/state/operator_bond.rs

@@ -0,0 +1,58 @@
+use wheels::{
+    fixed_offset_layout,
+    layout::{Decodable, Encodable},
+};
+
+use crate::{compat::Pubkey, solana_program::program_error::ProgramError};
+
+pub const OPERATOR_STATUS_ACTIVE: u8 = 1;
+pub const OPERATOR_STATUS_EXITING: u8 = 2;
+pub const OPERATOR_STATUS_SLASHED: u8 = 3;
+pub const OPERATOR_STATUS_JAILED: u8 = 4;
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+#[fixed_offset_layout(buffer_offset = 0)]
+pub struct OperatorBond {
+    pub operator_identity: Pubkey,
+    pub stake_lamports: u64,
+    pub locked_lamports: u64,
+    pub status: u8,
+    pub withdraw_requested_slot: Option<u64>,
+}
+
+impl OperatorBond {
+    pub const DISCRIMINATOR: [u8; 8] = *b"v2opbond";
+    pub const SPACE: usize = 8 + Self::DATA_LEN;
+
+    pub fn to_bytes_with_discriminator(
+        &self,
+        data: &mut [u8],
+    ) -> Result<(), ProgramError> {
+        let payload = super::utils::payload_with_discriminator_mut(
+            &Self::DISCRIMINATOR,
+            data,
+        )?;
+        self.encode_to(payload)
+            .map_err(super::utils::layout_error_to_program_error)?;
+        Ok(())
+    }
+
+    pub fn try_from_bytes_with_discriminator(
+        data: &[u8],
+    ) -> Result<Self, ProgramError> {
+        let payload = super::utils::payload_with_discriminator(
+            &Self::DISCRIMINATOR,
+            data,
+        )?;
+        let view = <Self as Decodable>::decode(payload)
+            .map_err(super::utils::layout_error_to_program_error)?;
+
+        Ok(Self {
+            operator_identity: *view.operator_identity(),
+            stake_lamports: view.stake_lamports(),
+            locked_lamports: view.locked_lamports(),
+            status: view.status(),
+            withdraw_requested_slot: view.withdraw_requested_slot(),
+        })
+    }
+}

src/v2/processor/bootstrap/mod.rs

@@ -1,3 +1,5 @@
 mod init_protocol_config;
+mod register_operator;
 
 pub use init_protocol_config::*;
+pub use register_operator::*;

src/v2/processor/bootstrap/register_operator.rs

@@ -0,0 +1,119 @@
+use dlp_api::{
+    error::DlpError,
+    v2::{
+        pda::{OPERATOR_BOND_SEED, PROTOCOL_CONFIG_SEED},
+        OperatorBond, ProtocolConfig, RegisterOperatorArgs,
+        OPERATOR_STATUS_ACTIVE,
+    },
+};
+use solana_sdk_ids::system_program;
+use solana_system_interface::instruction as system_instruction;
+
+use crate::{
+    processor::utils::{
+        loaders::{
+            load_initialized_pda, load_program, load_signer,
+            load_uninitialized_pda,
+        },
+        pda::create_pda,
+    },
+    solana_program::{
+        account_info::AccountInfo, entrypoint::ProgramResult, program::invoke,
+        program_error::ProgramError, pubkey::Pubkey,
+    },
+};
+
+/// Register one operator for v2 commitments.
+///
+/// Accounts:
+/// 0: `[signer, writable]` operator identity and stake payer
+/// 1: `[signer]`           protocol authority that admits the operator
+/// 2: `[writable]`         OperatorBond PDA
+/// 3: `[]`                 ProtocolConfig PDA
+/// 4: `[]`                 system program
+pub fn process_register_operator(
+    _program_id: &Pubkey,
+    accounts: &[AccountInfo],
+    data: &[u8],
+) -> ProgramResult {
+    let args = RegisterOperatorArgs::try_from_bytes(data)?;
+
+    let [operator, authority, operator_bond, protocol_config, system_program] =
+        accounts
+    else {
+        return Err(ProgramError::NotEnoughAccountKeys);
+    };
+
+    load_signer(operator, "operator")?;
+    load_signer(authority, "authority")?;
+    load_program(system_program, system_program::id(), "system program")?;
+
+    load_initialized_pda(
+        protocol_config,
+        &[PROTOCOL_CONFIG_SEED],
+        &crate::id(),
+        false,
+        "protocol config",
+    )?;
+
+    let protocol_config_data = protocol_config.try_borrow_data()?;
+    let protocol_config_state =
+        ProtocolConfig::try_from_bytes_with_discriminator(
+            protocol_config_data.as_ref(),
+        )?;
+
+    if protocol_config_state.authority != *authority.key {
+        return Err(DlpError::InvalidAuthority.into());
+    }
+
+    if *operator.key == Pubkey::default()
+        || args.amount_lamports < protocol_config_state.min_operator_bond
+    {
+        return Err(ProgramError::InvalidInstructionData);
+    }
+
+    let operator_bond_bump = load_uninitialized_pda(
+        operator_bond,
+        &[OPERATOR_BOND_SEED, operator.key.as_ref()],
+        &crate::id(),
+        true,
+        "operator bond",
+    )?;
+
+    create_pda(
+        operator_bond,
+        &crate::id(),
+        OperatorBond::SPACE,
+        &[OPERATOR_BOND_SEED, operator.key.as_ref()],
+        operator_bond_bump,
+        system_program,
+        operator,
+    )?;
+
+    invoke(
+        &system_instruction::transfer(
+            operator.key,
+            operator_bond.key,
+            args.amount_lamports,
+        ),
+        &[
+            operator.clone(),
+            operator_bond.clone(),
+            system_program.clone(),
+        ],
+    )?;
+
+    let operator_bond_state = OperatorBond {
+        operator_identity: *operator.key,
+        stake_lamports: args.amount_lamports,
+        locked_lamports: 0,
+        status: OPERATOR_STATUS_ACTIVE,
+        withdraw_requested_slot: None,
+    };
+
+    let mut operator_bond_data = operator_bond.try_borrow_mut_data()?;
+    operator_bond_state
+        .to_bytes_with_discriminator(operator_bond_data.as_mut())?;
+
+    Ok(())
+}