assert rkey order when driving

small (~3%) perf hit for this, which is fine

readme.md

···
 todo
 
 - [x] car file test fixtures & validation tests
-- [ ] make sure we can get the did and signature out for verification
+- [x] make sure we can get the did and signature out for verification
+  -> yeah the commit is returned from init
 - [ ] spec compliance todos
-  - [ ] assert that keys are ordered and fail if not
+  - [x] assert that keys are ordered and fail if not
   - [ ] verify node mst depth from key (possibly pending [interop test fixes](https://github.com/bluesky-social/atproto-interop-tests/issues/5))
 - [ ] performance todos
-  - [ ] consume the serialized nodes into a mutable efficient format
+  - [x] consume the serialized nodes into a mutable efficient format
     - [ ] maybe customize the deserialize impl to do that directly?
   - [x] benchmark and profile
 - [ ] robustness todos
   - [ ] swap the blocks hashmap for a BlockStore trait that can be dumped to redb
     - [ ] maybe keep the redb function behind a feature flag?
   - [ ] can we assert a max size for node blocks?
-  - [ ] figure out why asserting the upper nibble of the fourth byte of a node fails fingerprinting
+  - [x] figure out why asserting the upper nibble of the fourth byte of a node fails fingerprinting
+    -> because it's the upper 3 bytes, not upper 4 byte nibble, oops.
   - [ ] max mst depth (there is actually a hard limit but a malicious repo could do anything)
-  - [ ] i don't think we need a max recursion depth for processing cbor contents since we leave records to the user to decode
+  - [ ] i don't *think* we need a max recursion depth for processing cbor contents since we leave records to the user to decode
 
 newer ideas
 

src/drive.rs

···
 pub enum DriveError<E: Error> {
     #[error("Failed to initialize CarReader: {0}")]
     CarReader(#[from] iroh_car::Error),
-    #[error("CAR file requires a root to be present")]
-    MissingRoot,
     #[error("Car block stream error: {0}")]
     CarBlockError(Box<dyn Error>),
     #[error("Failed to decode commit block: {0}")]
     BadCommit(Box<dyn Error>),
-    #[error("Failed to decode record block: {0}")]
-    BadRecord(Box<dyn Error>),
     #[error("The Commit block reference by the root was not found")]
     MissingCommit,
     #[error("The MST block {0} could not be found")]
     MissingBlock(Cid),
     #[error("Failed to walk the mst tree: {0}")]
     Tripped(#[from] Trip<E>),
-    #[error("Not finished walking, but no more blocks are available to continue")]
-    Dnf,
+    #[error("Encountered an rkey out of order while walking the MST")]
+    RkeyOutOfOrder,
 }
 
 type CarBlock<E> = Result<(Cid, Vec<u8>), E>;
···
     blocks: HashMap<Cid, MaybeProcessedBlock<T, PE>>,
     walker: Walker,
     process: P,
+    prev_rkey: String,
 }
 
 impl<SE, S, T: Clone, P, PE> Vehicle<SE, S, T, P, PE>
···
                 let c: Commit = serde_ipld_dagcbor::from_slice(&data)
                     .map_err(|e| DriveError::BadCommit(e.into()))?;
                 commit = Some(c);
-                break; // inner while
+                break;
             } else {
                 blocks.insert(
                     cid,
···
             blocks,
             walker,
             process,
+            prev_rkey: "".to_string(),
         };
         Ok((commit, me))
     }
···
             let cid_needed = match self.walker.walk(&mut self.blocks, &self.process)? {
                 Step::Rest(cid) => cid,
                 Step::Finish => return Ok(None),
-                Step::Step { rkey, data } => return Ok(Some((Rkey(rkey), data))),
+                Step::Step { rkey, data } => {
+                    if rkey <= self.prev_rkey {
+                        return Err(DriveError::RkeyOutOfOrder);
+                    }
+                    return Ok(Some((Rkey(rkey), data)));
+                }
             };
 
             // load blocks until we reach that cid

src/walk.rs

···
     NodeEmpty,
     #[error("Failed to decode commit block: {0}")]
     BadCommit(Box<dyn std::error::Error>),
-    #[error("Failed to process record: {0}")]
-    RecordFailedProcessing(Box<dyn Error>),
     #[error("Action node error: {0}")]
     ActionNode(#[from] ActionNodeError),
     #[error("Process failed: {0}")]