feat(fraud-proofs): Implement RaiseChallenge

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

@@ -3,6 +3,7 @@
 
 mod init_protocol_config;
 mod post_commitment;
+mod raise_challenge;
 mod register_operator;
 mod register_verifier;
 mod update_protocol_config;
@@ -11,6 +12,7 @@ mod write_state_buffer;
 
 pub use init_protocol_config::*;
 pub use post_commitment::*;
+pub use raise_challenge::*;
 pub use register_operator::*;
 pub use register_verifier::*;
 pub use update_protocol_config::*;

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

@@ -0,0 +1,14 @@
+use wheels::variable_offset_layout;
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+#[variable_offset_layout(buffer_offset = 1)]
+pub struct RaiseChallengeArgs {
+    /// State commitment hash stored in the pending commitment being challenged.
+    pub state_commitment_hash: [u8; 32],
+
+    /// Salted hash binding the challenger state to this challenge.
+    pub challenge_hash: [u8; 32],
+
+    /// Lamports locked in the challenge account until reveal or resolution.
+    pub stake_lamports: u64,
+}

dlp-api/src/v2/instruction.rs

@@ -27,6 +27,8 @@ pub enum DlpV2Instruction {
     WriteStateBuffer = 107,
     /// Applies an approved v2 commitment to the delegated account.
     FinalizeCommitment = 108,
+    /// Raises a hash-only challenge against a v2 pending commitment.
+    RaiseChallenge = 109,
 }
 
 impl DlpV2Instruction {

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

@@ -2,6 +2,7 @@ mod approve_commitment;
 mod finalize_commitment;
 mod init_protocol_config;
 mod post_commitment;
+mod raise_challenge;
 mod register_operator;
 mod register_verifier;
 mod update_protocol_config;
@@ -12,6 +13,7 @@ pub use approve_commitment::*;
 pub use finalize_commitment::*;
 pub use init_protocol_config::*;
 pub use post_commitment::*;
+pub use raise_challenge::*;
 pub use register_operator::*;
 pub use register_verifier::*;
 pub use update_protocol_config::*;

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

@@ -0,0 +1,50 @@
+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::{challenge_pda, pending_commitment_pda, protocol_config_pda},
+        DlpV2Instruction, RaiseChallengeArgs,
+    },
+};
+
+/// Builds the instruction that raises a hash-only v2 challenge.
+pub fn raise_challenge(
+    challenger: Pubkey,
+    account: Pubkey,
+    commit_id: u64,
+    args: RaiseChallengeArgs,
+) -> Instruction {
+    Instruction {
+        program_id: crate::id().modernize(),
+        accounts: vec![
+            AccountMeta::new(challenger, true),
+            AccountMeta::new(
+                challenge_pda(
+                    &account.compatize(),
+                    commit_id,
+                    &challenger.compatize(),
+                )
+                .modernize(),
+                false,
+            ),
+            AccountMeta::new(
+                pending_commitment_pda(&account.compatize(), commit_id)
+                    .modernize(),
+                false,
+            ),
+            AccountMeta::new_readonly(protocol_config_pda().modernize(), false),
+            AccountMeta::new_readonly(system_program::id(), false),
+        ],
+        data: [
+            DlpV2Instruction::RaiseChallenge.to_vec(),
+            args.encode().unwrap(),
+        ]
+        .concat(),
+    }
+}

dlp-api/src/v2/pda.rs

@@ -6,6 +6,7 @@ pub const VERIFIER_BOND_SEED: &[u8] = b"verifier-bond";
 pub const VERIFIER_REGISTRY_SEED: &[u8] = b"verifier-registry";
 pub const STATE_BUFFER_SEED: &[u8] = b"state-buffer";
 pub const PENDING_COMMITMENT_SEED: &[u8] = b"pending-commitment";
+pub const CHALLENGE_SEED: &[u8] = b"challenge";
 
 // TODO (snawaz): Precompute these addresses if PDA derivation becomes const-safe.
 
@@ -61,3 +62,20 @@ pub fn pending_commitment_pda(account: &Pubkey, commit_id: u64) -> Pubkey {
     )
     .0
 }
+
+pub fn challenge_pda(
+    account: &Pubkey,
+    commit_id: u64,
+    challenger: &Pubkey,
+) -> Pubkey {
+    Pubkey::find_program_address(
+        &[
+            CHALLENGE_SEED,
+            account.as_ref(),
+            &commit_id.to_le_bytes(),
+            challenger.as_ref(),
+        ],
+        &crate::id(),
+    )
+    .0
+}

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

@@ -0,0 +1,67 @@
+use wheels::fixed_offset_layout;
+
+use crate::compat::Pubkey;
+
+pub const CHALLENGE_STATUS_AWAITING_REVEAL: u8 = 1;
+pub const CHALLENGE_STATUS_AWAITING_RESOLVER: u8 = 2;
+pub const CHALLENGE_STATUS_TERMINAL: u8 = 3;
+
+pub const CHALLENGE_OUTCOME_NONE: u8 = 0;
+pub const CHALLENGE_OUTCOME_INVALID_REVEAL: u8 = 1;
+pub const CHALLENGE_OUTCOME_MATCHING_STATE_CHALLENGER_PENALIZED: u8 = 2;
+
+/// PDA: `["challenge", account, commit_id, challenger]`.
+/// Created by `RaiseChallenge`.
+/// Closed by `CloseTerminalAccounts` after terminal challenge outcome.
+#[derive(Clone, Debug, PartialEq, Eq)]
+#[fixed_offset_layout(buffer_offset = 0)]
+pub struct Challenge {
+    /// Account type marker.
+    pub discriminator: [u8; 8],
+
+    /// Current challenge lifecycle state.
+    pub status: u8,
+
+    /// Terminal outcome, or `CHALLENGE_OUTCOME_NONE` before resolution.
+    pub outcome: u8,
+
+    /// Keeps the following fixed-width fields 8-byte aligned.
+    pub _pad_after_outcome: [u8; 6],
+
+    /// PendingCommitment being challenged.
+    pub pending_commitment: Pubkey,
+
+    /// Challenger that locked stake and owns the reveal.
+    pub challenger_identity: Pubkey,
+
+    /// State commitment hash copied from the pending commitment at raise time.
+    pub state_commitment_hash: [u8; 32],
+
+    /// Salted hash binding the challenger state to this challenge.
+    pub challenge_hash: [u8; 32],
+
+    /// Challenger-revealed account lamports. Zero until reveal.
+    pub challenger_lamports: u64,
+
+    /// Challenger-revealed account owner. Default pubkey until reveal.
+    pub challenger_owner: Pubkey,
+
+    /// Challenger-revealed account data hash. Zero until reveal.
+    pub challenger_data_hash: [u8; 32],
+
+    /// Challenger StateBuffer PDA used for reveal. Default pubkey until reveal.
+    pub challenger_state_buffer: Pubkey,
+
+    /// Lamports locked in this challenge account.
+    pub challenger_stake_lamports: u64,
+
+    /// Slot when the challenge was raised.
+    pub raised_slot: u64,
+
+    /// Slot after which an unrevealed challenge can be timed out.
+    pub reveal_deadline_slot: u64,
+}
+
+impl Challenge {
+    pub const DISCRIMINATOR: [u8; 8] = *b"v2chal00";
+}

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

@@ -1,10 +1,12 @@
+mod challenge;
 mod operator_bond;
 mod pending_commitment;
 mod protocol_config;
 mod state_buffer;
 mod verifier_bond;
 mod verifier_registry;
 
+pub use challenge::*;
 pub use operator_bond::*;
 pub use pending_commitment::*;
 pub use protocol_config::*;

src/v2/processor/fraud_proofs/mod.rs

@@ -3,9 +3,11 @@
 mod approve_commitment;
 mod finalize_commitment;
 mod post_commitment;
+mod raise_challenge;
 mod write_state_buffer;
 
 pub use approve_commitment::*;
 pub use finalize_commitment::*;
 pub use post_commitment::*;
+pub use raise_challenge::*;
 pub use write_state_buffer::*;