Make protocol extensible for external verification backends

Author: jimmdd

README.md

@@ -41,6 +41,28 @@ Initial protocol scaffold for TaskForest: a proof-first task network where human
   - settlement requires valid status + proof where applicable
   - timeout expiration can force fail settlement with reason `DEADLINE_EXPIRED`
 
+## Extension-ready design (Arcium + MagicBlock)
+
+This scaffold is intentionally not fixed to a single verification/execution path.
+
+- `VerificationBackend` enum supports:
+  - `Native`
+  - `Arcium`
+  - `MagicBlock`
+  - `Hybrid`
+  - `Custom(String)` for forward-compatible providers
+- Settlement records backend metadata:
+  - `verification_backend`
+  - `verification_ref` (attestation/proof/receipt URI)
+- Proof submissions accept extensible evidence vectors:
+  - `evidence_refs: Vec<String>`
+- Protocol capabilities are runtime-configurable:
+  - `allow_confidential_verification`
+  - `allow_realtime_execution`
+  - `extension_flags: HashMap<String, String>`
+
+This means Arcium confidential attestations and MagicBlock real-time session receipts can be added without changing the core job lifecycle model.
+
 ### Instruction payload format (current scaffold)
 
 Current decoder uses simple pipe-delimited payloads for rapid iteration:
@@ -53,6 +75,12 @@ settle_job|<job_id>|<pass|fail|needs_judge>|<reason_code>|<now>
 open_dispute|<job_id>
 cancel_job|<job_id>|<poster>
 expire_claim|<job_id>|<now>
+
+# optional backend metadata on settle
+settle_job|<job_id>|<pass|fail|needs_judge>|<reason_code>|<now>|<backend>|<verification_ref>
+
+# optional evidence refs on submit_proof
+submit_proof|<job_id>|<submitter>|<proof_hash>|<now>|<evidence_ref_1>|<evidence_ref_2>|...
 ```
 
 This will be replaced by compact binary instruction encoding in the on-chain Pinocchio layer.

src/instruction.rs

@@ -1,6 +1,6 @@
 use crate::{
     ActorId, CancelJobParams, ClaimJobParams, CreateJobParams, ExpireClaimParams, JobId,
-    SettleJobParams, SubmitProofParams, Verdict,
+    SettleJobParams, SubmitProofParams, Verdict, VerificationBackend,
 };
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -60,25 +60,38 @@ impl TaskForestInstruction {
                 }))
             }
             "submit_proof" => {
-                if parts.len() != 5 {
+                if parts.len() < 5 {
                     return Err(InstructionDecodeError::InvalidFormat);
                 }
                 Ok(Self::SubmitProof(SubmitProofParams {
                     job_id: parse_u64(parts[1])?,
                     submitter: parse_actor(parts[2]),
                     proof_hash: parts[3].to_string(),
                     now_epoch_secs: parse_u64(parts[4])?,
+                    evidence_refs: parts[5..].iter().map(|v| (*v).to_string()).collect(),
                 }))
             }
             "settle_job" => {
-                if parts.len() != 5 {
+                if parts.len() != 5 && parts.len() != 6 && parts.len() != 7 {
                     return Err(InstructionDecodeError::InvalidFormat);
                 }
+                let backend = if parts.len() >= 6 {
+                    parse_backend(parts[5])
+                } else {
+                    VerificationBackend::Native
+                };
+                let verification_ref = if parts.len() == 7 {
+                    Some(parts[6].to_string())
+                } else {
+                    None
+                };
                 Ok(Self::SettleJob(SettleJobParams {
                     job_id: parse_u64(parts[1])?,
                     verdict: parse_verdict(parts[2])?,
                     reason_code: parts[3].to_string(),
                     now_epoch_secs: parse_u64(parts[4])?,
+                    verification_backend: backend,
+                    verification_ref,
                 }))
             }
             "open_dispute" => {
@@ -129,6 +142,16 @@ fn parse_verdict(value: &str) -> Result<Verdict, InstructionDecodeError> {
     }
 }
 
+fn parse_backend(value: &str) -> VerificationBackend {
+    match value {
+        "native" => VerificationBackend::Native,
+        "arcium" => VerificationBackend::Arcium,
+        "magicblock" => VerificationBackend::MagicBlock,
+        "hybrid" => VerificationBackend::Hybrid,
+        other => VerificationBackend::Custom(other.to_string()),
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -161,4 +184,24 @@ mod tests {
         let result = TaskForestInstruction::unpack(b"submit_proof|1|proof-hash-only|2000");
         assert_eq!(result, Err(InstructionDecodeError::InvalidFormat));
     }
+
+    #[test]
+    fn settle_instruction_supports_backend_and_ref() {
+        let instruction = TaskForestInstruction::unpack(
+            b"settle_job|77|pass|CHECKS_PASS_ALL|1000|arcium|arcium://proof/77",
+        )
+        .expect("settle should unpack");
+
+        match instruction {
+            TaskForestInstruction::SettleJob(params) => {
+                assert_eq!(params.job_id, 77);
+                assert_eq!(params.verification_backend, VerificationBackend::Arcium);
+                assert_eq!(
+                    params.verification_ref,
+                    Some("arcium://proof/77".to_string())
+                );
+            }
+            _ => panic!("expected settle instruction"),
+        }
+    }
 }