feat(fraud-proofs): Implement RegisterVerifier

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

@@ -3,6 +3,8 @@
 
 mod init_protocol_config;
 mod register_operator;
+mod register_verifier;
 
 pub use init_protocol_config::*;
 pub use register_operator::*;
+pub use register_verifier::*;

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

@@ -0,0 +1,7 @@
+use wheels::variable_offset_layout;
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+#[variable_offset_layout(buffer_offset = 1)]
+pub struct RegisterVerifierArgs {
+    pub stake_lamports: u64,
+}

dlp-api/src/v2/instruction.rs

@@ -9,6 +9,8 @@ pub enum DlpV2Instruction {
     InitProtocolConfig = 100,
     /// Registers one operator and deposits its initial stake.
     RegisterOperator = 101,
+    /// Registers one verifier and deposits its initial stake.
+    RegisterVerifier = 102,
 }
 
 impl DlpV2Instruction {

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

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

dlp-api/src/v2/instruction_builder/register_verifier.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::{protocol_config_pda, verifier_bond_pda},
+        DlpV2Instruction, RegisterVerifierArgs,
+    },
+};
+
+/// Builds the instruction that registers one verifier for v2 approvals.
+pub fn register_verifier(
+    verifier: Pubkey,
+    authority: Pubkey,
+    args: RegisterVerifierArgs,
+) -> Instruction {
+    Instruction {
+        program_id: crate::id().modernize(),
+        accounts: vec![
+            AccountMeta::new(verifier, true),
+            AccountMeta::new_readonly(authority, true),
+            AccountMeta::new(
+                verifier_bond_pda(&verifier.compatize()).modernize(),
+                false,
+            ),
+            AccountMeta::new_readonly(protocol_config_pda().modernize(), false),
+            AccountMeta::new_readonly(system_program::id(), false),
+        ],
+        data: [
+            DlpV2Instruction::RegisterVerifier.to_vec(),
+            args.encode().unwrap(),
+        ]
+        .concat(),
+    }
+}

dlp-api/src/v2/pda.rs

@@ -2,6 +2,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_BOND_SEED: &[u8] = b"verifier-bond";
 pub const VERIFIER_REGISTRY_SEED: &[u8] = b"verifier-registry";
 
 // TODO (snawaz): Precompute these addresses if PDA derivation becomes const-safe.
@@ -21,3 +22,11 @@ pub fn operator_bond_pda(operator: &Pubkey) -> Pubkey {
     )
     .0
 }
+
+pub fn verifier_bond_pda(verifier: &Pubkey) -> Pubkey {
+    Pubkey::find_program_address(
+        &[VERIFIER_BOND_SEED, verifier.as_ref()],
+        &crate::id(),
+    )
+    .0
+}

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

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

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

@@ -0,0 +1,53 @@
+use wheels::fixed_offset_layout;
+
+use crate::compat::Pubkey;
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+#[fixed_offset_layout(buffer_offset = 0)]
+pub struct VerifierBond {
+    /// Account type marker.
+    pub discriminator: [u8; 8],
+
+    /// Canonical PDA bump for this account.
+    pub bump: u8,
+
+    /// Verifier identity allowed to approve commitments through this bond.
+    pub verifier_identity: Pubkey,
+
+    /// Slashable verifier 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,
+
+    /// Current verifier lifecycle state, stored as `VerifierStatus::value()`.
+    pub status: u8,
+
+    /// Slot when the verifier registered.
+    /// CHECKPOINT: keep this only if future verifier eligibility rules compare
+    /// the current slot with this registration slot, such as requiring a newly
+    /// registered verifier to wait before it can be selected or approve.
+    pub registered_slot: u64,
+
+    /// Slot when withdrawal was requested, if the verifier is exiting.
+    pub withdraw_requested_slot: Option<u64>,
+}
+
+impl VerifierBond {
+    pub const DISCRIMINATOR: [u8; 8] = *b"v2vrbond";
+}
+
+#[repr(u8)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum VerifierStatus {
+    Active = 1,
+    Exiting = 2,
+    Slashed = 3,
+    Jailed = 4,
+}
+
+impl VerifierStatus {
+    pub const fn value(self) -> u8 {
+        self as u8
+    }
+}

src/v2/processor/bootstrap/mod.rs

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

src/v2/processor/bootstrap/register_verifier.rs

@@ -0,0 +1,120 @@
+use dlp_api::{
+    error::DlpError,
+    v2::{
+        pda::{PROTOCOL_CONFIG_SEED, VERIFIER_BOND_SEED},
+        ProtocolConfig, RegisterVerifierArgs, VerifierBond, VerifierStatus,
+    },
+};
+use pinocchio::{
+    cpi::{Seed, Signer},
+    error::ProgramError,
+    sysvars::{clock::Clock, Sysvar},
+    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 verifier for v2 approvals.
+///
+/// Accounts:
+/// 0: `[signer, writable]` verifier identity and stake payer
+/// 1: `[signer]`           protocol authority that admits the verifier
+/// 2: `[writable]`         VerifierBond PDA
+/// 3: `[]`                 ProtocolConfig PDA
+/// 4: `[]`                 system program, required by system CPI
+#[inline(never)]
+pub fn process_register_verifier(
+    accounts: &[AccountView],
+    data: &[u8],
+) -> ProgramResult {
+    let [
+        verifier, // force multi-line
+        authority,
+        verifier_bond,
+        protocol_config,
+        _system_program,
+    ] = require_n_accounts!(accounts, 5);
+
+    require_signer!(verifier);
+    require_signer!(authority);
+
+    let args = RegisterVerifierArgs::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_verifier_bond(),
+        ProgramError::InvalidInstructionData
+    );
+
+    drop(protocol_config_data);
+
+    let verifier_bond_bump = require_uninitialized_pda(
+        verifier_bond,
+        &[VERIFIER_BOND_SEED, verifier.address().as_ref()],
+        &crate::fast::ID,
+        true,
+        StandardCtx::new("verifier bond"),
+    )?;
+
+    create_pda(
+        verifier_bond,
+        &crate::fast::ID,
+        VerifierBond::DATA_LEN,
+        &[Signer::from(&[
+            Seed::from(VERIFIER_BOND_SEED),
+            Seed::from(verifier.address().as_ref()),
+            Seed::from(&[verifier_bond_bump]),
+        ])],
+        verifier,
+    )?;
+
+    system::Transfer {
+        from: verifier,
+        to: verifier_bond,
+        lamports: args.stake_lamports(),
+    }
+    .invoke()?;
+
+    VerifierBond {
+        discriminator: VerifierBond::DISCRIMINATOR,
+        bump: verifier_bond_bump,
+        verifier_identity: verifier.address().to_bytes().into(),
+        stake_lamports: args.stake_lamports(),
+        status: VerifierStatus::Active.value(),
+        registered_slot: Clock::get()?.slot,
+        withdraw_requested_slot: None,
+    }
+    .encode_to(verifier_bond.try_borrow_mut()?.as_mut())?;
+
+    Ok(())
+}

src/v2/processor/mod.rs

@@ -19,5 +19,8 @@ pub fn process_instruction(
         DlpV2Instruction::RegisterOperator => {
             process_register_operator(accounts, data)
         }
+        DlpV2Instruction::RegisterVerifier => {
+            process_register_verifier(accounts, data)
+        }
     }
 }