feat(fraud-proofs): Implement RegisterOperator

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

@@ -2,5 +2,7 @@
 // instruction tag, so v2 instruction args use `buffer_offset = 1`.
 
 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,7 @@
+use wheels::variable_offset_layout;
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+#[variable_offset_layout(buffer_offset = 1)]
+pub struct RegisterOperatorArgs {
+    pub stake_lamports: u64,
+}

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";
 
 // TODO (snawaz): Precompute these addresses if PDA derivation becomes const-safe.
@@ -12,3 +13,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,5 +1,7 @@
+mod operator_bond;
 mod protocol_config;
 mod verifier_registry;
 
+pub use operator_bond::*;
 pub use protocol_config::*;
 pub use verifier_registry::*;

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

@@ -0,0 +1,51 @@
+use wheels::fixed_offset_layout;
+
+use crate::compat::Pubkey;
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+#[fixed_offset_layout(buffer_offset = 0)]
+pub struct OperatorBond {
+    /// Account type marker.
+    pub discriminator: [u8; 8],
+
+    /// Canonical PDA bump for this account.
+    pub bump: u8,
+
+    /// Operator identity allowed to post commitments through this bond.
+    pub operator_identity: Pubkey,
+
+    /// Slashable operator stake held in this account.
+    /// CHECKPOINT: the staking asset is SOL or BLOCK?
+    /// If this changes to BLOCK, this field will need to point at token-account
+    /// accounting instead of native lamports.
+    pub stake_lamports: u64,
+
+    /// Stake reserved by active commitments.
+    /// CHECKPOINT: the staking asset is SOL or BLOCK?
+    pub locked_lamports: u64,
+
+    /// Current operator lifecycle state, stored as `OperatorStatus::value()`.
+    pub status: u8,
+
+    /// Slot when withdrawal was requested, if the operator is exiting.
+    pub withdraw_requested_slot: Option<u64>,
+}
+
+impl OperatorBond {
+    pub const DISCRIMINATOR: [u8; 8] = *b"v2opbond";
+}
+
+#[repr(u8)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum OperatorStatus {
+    Active = 1,
+    Exiting = 2,
+    Slashed = 3,
+    Jailed = 4,
+}
+
+impl OperatorStatus {
+    pub const fn value(self) -> u8 {
+        self as u8
+    }
+}

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, OperatorStatus, ProtocolConfig, RegisterOperatorArgs,
+    },
+};
+use pinocchio::{
+    cpi::{Seed, Signer},
+    error::ProgramError,
+    AccountView, ProgramResult,
+};
+use pinocchio_system::instructions as system;
+use wheels::{
+    layout::{Decodable, Encodable},
+    require, require_eq_keys, require_ge, require_n_accounts, require_signer,
+};
+
+use crate::{
+    processor::fast::utils::pda::create_pda,
+    requires::{
+        require_initialized_pda, require_uninitialized_pda, StandardCtx,
+    },
+};
+
+/// 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, required by system CPI
+#[inline(never)]
+pub fn process_register_operator(
+    accounts: &[AccountView],
+    data: &[u8],
+) -> ProgramResult {
+    let [
+        operator, // force multi-line
+        authority,
+        operator_bond,
+        protocol_config,
+        _system_program,
+    ] = require_n_accounts!(accounts, 5);
+
+    require_signer!(operator);
+    require_signer!(authority);
+
+    let args = RegisterOperatorArgs::decode(data)?;
+
+    require_initialized_pda(
+        protocol_config,
+        &[PROTOCOL_CONFIG_SEED],
+        &crate::fast::ID,
+        false,
+        "protocol config",
+    )?;
+    let protocol_config_data = protocol_config.try_borrow()?;
+    let protocol_config_state =
+        ProtocolConfig::decode(protocol_config_data.as_ref())?;
+    require!(
+        protocol_config_state.discriminator() == ProtocolConfig::DISCRIMINATOR,
+        ProgramError::InvalidAccountData
+    );
+
+    require_eq_keys!(
+        protocol_config_state.authority(),
+        authority.address(),
+        DlpError::InvalidAuthority
+    );
+    require_ge!(
+        args.stake_lamports(),
+        protocol_config_state.min_operator_bond(),
+        ProgramError::InvalidInstructionData
+    );
+
+    drop(protocol_config_data);
+
+    let operator_bond_bump = require_uninitialized_pda(
+        operator_bond,
+        &[OPERATOR_BOND_SEED, operator.address().as_ref()],
+        &crate::fast::ID,
+        true,
+        StandardCtx::new("operator bond"),
+    )?;
+
+    create_pda(
+        operator_bond,
+        &crate::fast::ID,
+        OperatorBond::DATA_LEN,
+        &[Signer::from(&[
+            Seed::from(OPERATOR_BOND_SEED),
+            Seed::from(operator.address().as_ref()),
+            Seed::from(&[operator_bond_bump]),
+        ])],
+        operator,
+    )?;
+
+    system::Transfer {
+        from: operator,
+        to: operator_bond,
+        lamports: args.stake_lamports(),
+    }
+    .invoke()?;
+
+    OperatorBond {
+        discriminator: OperatorBond::DISCRIMINATOR,
+        bump: operator_bond_bump,
+        operator_identity: operator.address().to_bytes().into(),
+        stake_lamports: args.stake_lamports(),
+        locked_lamports: 0,
+        status: OperatorStatus::Active.value(),
+        withdraw_requested_slot: None,
+    }
+    .encode_to(operator_bond.try_borrow_mut()?.as_mut())?;
+
+    Ok(())
+}

src/v2/processor/mod.rs

@@ -16,5 +16,8 @@ pub fn process_instruction(
         DlpV2Instruction::InitProtocolConfig => {
             process_init_protocol_config(accounts, data)
         }
+        DlpV2Instruction::RegisterOperator => {
+            process_register_operator(accounts, data)
+        }
     }
 }

tests/fixtures/mod.rs

@@ -1,4 +1,5 @@
 pub mod accounts;
+pub mod v2;
 
 #[allow(unused_imports)]
 pub(crate) use accounts::*;

tests/fixtures/v2.rs

@@ -0,0 +1,69 @@
+use dlp_api::v2::{
+    instruction_builder::init_protocol_config, InitProtocolConfigArgs,
+};
+use solana_program::{
+    hash::Hash, native_token::LAMPORTS_PER_SOL, pubkey::Pubkey,
+};
+use solana_program_test::{BanksClient, ProgramTest};
+use solana_sdk::{
+    account::Account,
+    signature::{Keypair, Signer},
+    transaction::Transaction,
+};
+use solana_sdk_ids::system_program;
+
+pub fn valid_protocol_config_args() -> InitProtocolConfigArgs {
+    InitProtocolConfigArgs {
+        resolver: Pubkey::new_unique(),
+        min_operator_bond: 1,
+        min_verifier_bond: 1,
+        min_challenger_stake: 1,
+        challenge_window_slots: 10,
+        operator_response_timeout_slots: 10,
+        challenger_reveal_timeout_slots: 10,
+        payout_timelock_slots: 10,
+        verifiers_per_commitment: 1,
+        approval_threshold: 1,
+        max_window_extensions: 1,
+        match_penalty_bps: 500,
+    }
+}
+
+#[allow(dead_code)]
+pub async fn initialize_protocol_config(
+    banks: &BanksClient,
+    payer: &Keypair,
+    authority: &Keypair,
+    blockhash: Hash,
+    args: InitProtocolConfigArgs,
+) {
+    let ix = init_protocol_config(authority.pubkey(), args);
+    let tx = Transaction::new_signed_with_payer(
+        &[ix],
+        Some(&payer.pubkey()),
+        &[payer, authority],
+        blockhash,
+    );
+
+    banks.process_transaction(tx).await.unwrap();
+}
+
+pub async fn setup_program_test_env() -> (BanksClient, Keypair, Keypair, Hash) {
+    let mut program_test = ProgramTest::new("dlp", dlp_api::ID, None);
+    program_test.prefer_bpf(true);
+
+    let authority = Keypair::new();
+    program_test.add_account(
+        authority.pubkey(),
+        Account {
+            lamports: LAMPORTS_PER_SOL,
+            data: vec![],
+            owner: system_program::id(),
+            executable: false,
+            rent_epoch: 0,
+        },
+    );
+
+    let (banks, payer, blockhash) = program_test.start().await;
+    (banks, payer, authority, blockhash)
+}