feat(fraud-proofs): Implement PostCommitment

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

@@ -2,13 +2,15 @@
 // instruction tag, so v2 instruction args use `buffer_offset = 1`.
 
 mod init_protocol_config;
+mod post_commitment;
 mod register_operator;
 mod register_verifier;
 mod update_protocol_config;
 mod update_verifier_registry;
 mod write_state_buffer;
 
 pub use init_protocol_config::*;
+pub use post_commitment::*;
 pub use register_operator::*;
 pub use register_verifier::*;
 pub use update_protocol_config::*;

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

@@ -0,0 +1,19 @@
+use wheels::variable_offset_layout;
+
+use crate::compat::Pubkey;
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+#[variable_offset_layout(buffer_offset = 1)]
+pub struct PostCommitmentArgs {
+    pub commit_id: u64,
+
+    pub lamports: u64,
+
+    pub owner: Pubkey,
+
+    /// Hash of replay/data-availability pointer bytes.
+    pub da_pointer_hash: [u8; 32],
+
+    /// ER slot that produced this commitment, when available.
+    pub er_slot: Option<u64>,
+}

dlp-api/src/v2/instruction.rs

@@ -15,6 +15,8 @@ pub enum DlpV2Instruction {
     UpdateVerifierRegistry = 103,
     /// Updates global v2 config for future commitments.
     UpdateProtocolConfig = 104,
+    /// Posts a new v2 account-state commitment.
+    PostCommitment = 105,
     /// Writes full account-state bytes into a v2 state buffer.
     ///
     /// TODO (snawaz/optimization): we can split this into two instructions such that 

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

@@ -1,11 +1,13 @@
 mod init_protocol_config;
+mod post_commitment;
 mod register_operator;
 mod register_verifier;
 mod update_protocol_config;
 mod update_verifier_registry;
 mod write_state_buffer;
 
 pub use init_protocol_config::*;
+pub use post_commitment::*;
 pub use register_operator::*;
 pub use register_verifier::*;
 pub use update_protocol_config::*;

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

@@ -0,0 +1,66 @@
+use solana_program::{
+    instruction::{AccountMeta, Instruction},
+    pubkey::Pubkey,
+};
+use solana_sdk_ids::system_program;
+use wheels::layout::Encodable;
+
+use crate::{
+    compat::{Compatize, Modernize},
+    pda::delegation_record_pda_from_delegated_account,
+    v2::{
+        pda::{
+            operator_bond_pda, pending_commitment_pda, protocol_config_pda,
+            state_buffer_pda, verifier_registry_pda,
+        },
+        DlpV2Instruction, PostCommitmentArgs,
+    },
+};
+
+/// Builds the instruction that posts one v2 account-state commitment.
+pub fn post_commitment(
+    operator: Pubkey,
+    account: Pubkey,
+    args: PostCommitmentArgs,
+) -> Instruction {
+    Instruction {
+        program_id: crate::id().modernize(),
+        accounts: vec![
+            AccountMeta::new(operator, true),
+            AccountMeta::new_readonly(
+                operator_bond_pda(&operator.compatize()).modernize(),
+                false,
+            ),
+            AccountMeta::new(
+                pending_commitment_pda(&account.compatize(), args.commit_id)
+                    .modernize(),
+                false,
+            ),
+            AccountMeta::new_readonly(
+                state_buffer_pda(
+                    &account.compatize(),
+                    args.commit_id,
+                    &operator.compatize(),
+                )
+                .modernize(),
+                false,
+            ),
+            AccountMeta::new_readonly(account, false),
+            AccountMeta::new_readonly(
+                delegation_record_pda_from_delegated_account(
+                    &account.compatize(),
+                )
+                .modernize(),
+                false,
+            ),
+            AccountMeta::new_readonly(protocol_config_pda().modernize(), false),
+            AccountMeta::new(verifier_registry_pda().modernize(), false),
+            AccountMeta::new_readonly(system_program::id(), false),
+        ],
+        data: [
+            DlpV2Instruction::PostCommitment.to_vec(),
+            args.encode().unwrap(),
+        ]
+        .concat(),
+    }
+}

dlp-api/src/v2/pda.rs

@@ -5,6 +5,7 @@ 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";
 pub const STATE_BUFFER_SEED: &[u8] = b"state-buffer";
+pub const PENDING_COMMITMENT_SEED: &[u8] = b"pending-commitment";
 
 // TODO (snawaz): Precompute these addresses if PDA derivation becomes const-safe.
 
@@ -48,3 +49,15 @@ pub fn state_buffer_pda(
     )
     .0
 }
+
+pub fn pending_commitment_pda(account: &Pubkey, commit_id: u64) -> Pubkey {
+    Pubkey::find_program_address(
+        &[
+            PENDING_COMMITMENT_SEED,
+            account.as_ref(),
+            &commit_id.to_le_bytes(),
+        ],
+        &crate::id(),
+    )
+    .0
+}

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

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

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

@@ -0,0 +1,118 @@
+use wheels::fixed_offset_layout;
+
+use crate::compat::Pubkey;
+
+pub const PENDING_COMMITMENT_STATUS_ACTIVE: u8 = 1;
+pub const PENDING_COMMITMENT_STATUS_AWAITING_OPERATOR_RESPONSE: u8 = 2;
+pub const PENDING_COMMITMENT_STATUS_AWAITING_CHALLENGER_REVEAL: u8 = 3;
+pub const PENDING_COMMITMENT_STATUS_AWAITING_DISPUTE_RESOLUTION: u8 = 4;
+pub const PENDING_COMMITMENT_STATUS_RESOLVED_OPERATOR: u8 = 5;
+pub const PENDING_COMMITMENT_STATUS_RESOLVED_CHALLENGER: u8 = 6;
+pub const PENDING_COMMITMENT_STATUS_FINALIZED: u8 = 7;
+pub const PENDING_COMMITMENT_STATUS_EXPIRED: u8 = 8;
+pub const PENDING_COMMITMENT_STATUS_CANCELLED: u8 = 9;
+
+pub const RESOLVED_STATE_SOURCE_OPERATOR_COMMITMENT: u8 = 1;
+pub const RESOLVED_STATE_SOURCE_CHALLENGER_REVEAL: u8 = 2;
+
+/// PDA: `["pending-commitment", account, commit_id]`.
+/// Created by `PostCommitment`.
+/// Closed by `CloseTerminalAccounts` after finalize, cancel, or expiry.
+///
+/// One account per delegated account and commit id.
+#[derive(Clone, Debug, PartialEq, Eq)]
+#[fixed_offset_layout(buffer_offset = 0)]
+pub struct PendingCommitment {
+    /// Account type marker.
+    pub discriminator: [u8; 8],
+
+    /// Current state-machine state for this commitment.
+    pub status: u8,
+
+    /// Operator identity that posted the commitment.
+    pub operator_identity: Pubkey,
+
+    /// OperatorBond checked when the commitment was posted.
+    pub operator_bond: Pubkey,
+
+    /// Delegated account whose base-layer state will be finalized.
+    pub account_pubkey: Pubkey,
+
+    /// Operator-chosen nonce for this account commitment.
+    pub commit_id: u64,
+
+    /// Delegation record tying this account to the ER context.
+    pub delegation_record: Pubkey,
+
+    /// Hash of replay/data-availability pointer bytes.
+    pub da_pointer_hash: [u8; 32],
+
+    /// Hash of lamports, owner, and data_hash.
+    pub account_state_hash: [u8; 32],
+
+    /// Hash of full account data.
+    pub data_hash: [u8; 32],
+
+    /// Lamports committed by the operator.
+    pub lamports: u64,
+
+    /// Owner committed by the operator.
+    pub owner: Pubkey,
+
+    /// Hash binding operator, account, commit id, delegation, DA, and state.
+    pub state_commitment_hash: [u8; 32],
+
+    /// Registry account used when this commitment was posted.
+    pub verifier_registry: Pubkey,
+
+    /// Monotonic id for this approval/challenge window.
+    pub challenge_window_id: u64,
+
+    /// Slot when the commitment was posted.
+    pub posted_slot: u64,
+
+    /// Slot when verifier selection and the challenge window started.
+    pub activation_slot: u64,
+
+    /// Slot when approval/challenge window closes.
+    pub challenge_window_end_slot: u64,
+
+    /// Number of unique selected verifiers that approved.
+    pub approval_count: u16,
+
+    /// Threshold copied from ProtocolConfig when the commitment is posted.
+    pub approval_threshold: u16,
+
+    /// Active Challenge account, if any.
+    pub active_challenge: Option<Pubkey>,
+
+    /// Which opened state finalization must use after dispute resolution.
+    pub resolved_state_source: Option<u8>,
+
+    /// ER slot that produced this commitment, when available.
+    pub er_slot: Option<u64>,
+
+    /// Aligns selected verifier elements after the Vec length prefix.
+    pub _pad_before_selected_verifiers: [u8; 7],
+
+    /// Verifiers selected by round-robin for this commitment.
+    #[extendable = 2]
+    pub selected_verifiers: Vec<SelectedVerifier>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+#[fixed_offset_layout(buffer_offset = 2)]
+pub struct SelectedVerifier {
+    /// Selected verifier identity.
+    pub verifier_identity: Pubkey,
+
+    /// Whether this verifier has approved this commitment.
+    pub approved: bool,
+
+    /// Keeps each Vec element aligned for fixed-layout decoding.
+    pub _pad_after_approved: [u8; 7],
+}
+
+impl PendingCommitment {
+    pub const DISCRIMINATOR: [u8; 8] = *b"v2pend00";
+}

src/v2/processor/fraud_proofs/mod.rs

@@ -1,5 +1,7 @@
 //! Processors for v2 fraud-proof instructions.
 
+mod post_commitment;
 mod write_state_buffer;
 
+pub use post_commitment::*;
 pub use write_state_buffer::*;