fix: tests for self-anchoring and self-proof storage

m0ar · m0ar · commit e88e11595a89 · 2026-01-08T19:04:58.000+01:00
diff --git a/event-svc/src/blockchain/mod.rs b/event-svc/src/blockchain/mod.rs
@@ -10,3 +10,98 @@ pub mod eth_rpc;
 pub(crate) fn tx_hash_try_from_cid(cid: Cid) -> anyhow::Result<TxHash> {
     Ok(TxHash::from_str(&hex::encode(cid.hash().digest()))?)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use multihash_codetable::{Code, MultihashDigest};
+
+    /// Ethereum transaction codec for IPLD (from multicodec table)
+    /// This matches the constant in anchor-evm/src/proof_builder.rs
+    const ETH_TX_CODEC: u64 = 0x93;
+
+    /// Simulate what ProofBuilder::tx_hash_to_cid does
+    fn simulate_proof_builder_tx_hash_to_cid(tx_hash: &str) -> Cid {
+        let hex_str = tx_hash.strip_prefix("0x").unwrap_or(tx_hash);
+        let tx_bytes = hex::decode(hex_str).unwrap();
+        let multihash = Code::Keccak256.wrap(&tx_bytes).unwrap();
+        Cid::new_v1(ETH_TX_CODEC, multihash)
+    }
+
+    #[test]
+    fn test_tx_hash_roundtrip_self_anchor_to_lookup() {
+        // critical invariant: what self-anchoring stores must match what lookup queries
+        let original_tx_hash = "0xa1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2";
+
+        // Step 1: ProofBuilder creates a CID from the tx_hash (simulated here)
+        let tx_cid = simulate_proof_builder_tx_hash_to_cid(original_tx_hash);
+
+        // Step 2: Validation converts CID back to tx_hash for lookup
+        let lookup_tx_hash = tx_hash_try_from_cid(tx_cid).unwrap().to_string();
+
+        // Step 3: Verify they match (both should be 0x-prefixed lowercase hex)
+        assert_eq!(
+            original_tx_hash.to_lowercase(),
+            lookup_tx_hash.to_lowercase(),
+            "Self-anchored tx_hash must match lookup tx_hash for chain proof discovery to work"
+        );
+    }
+
+    #[test]
+    fn test_tx_hash_roundtrip_without_0x_prefix() {
+        // Test that round-trip works even without 0x prefix in original
+        let original_tx_hash = "a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2";
+
+        let tx_cid = simulate_proof_builder_tx_hash_to_cid(original_tx_hash);
+        let lookup_tx_hash = tx_hash_try_from_cid(tx_cid).unwrap().to_string();
+
+        // TxHash::to_string() always adds 0x prefix
+        assert_eq!(
+            format!("0x{}", original_tx_hash.to_lowercase()),
+            lookup_tx_hash.to_lowercase()
+        );
+    }
+
+    #[test]
+    fn test_tx_hash_format_matches_alloy_txhash() {
+        // Verify that our round-trip produces the same format as alloy's TxHash::to_string()
+        let tx_hash_hex = "a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2";
+        let tx_cid = simulate_proof_builder_tx_hash_to_cid(tx_hash_hex);
+
+        let recovered = tx_hash_try_from_cid(tx_cid).unwrap();
+
+        // Create TxHash directly from the same hex
+        let direct = TxHash::from_str(tx_hash_hex).unwrap();
+
+        assert_eq!(recovered, direct);
+        assert_eq!(recovered.to_string(), direct.to_string());
+    }
+
+    #[test]
+    fn test_tx_hash_roundtrip_mixed_case() {
+        // Test that mixed-case hex input produces correct round-trip.
+        // Ethereum tx hashes are case-insensitive, but our storage uses lowercase.
+        // This verifies the normalization works correctly.
+        let mixed_case_tx_hash =
+            "0xAbCdEf1234567890AbCdEf1234567890AbCdEf1234567890AbCdEf1234567890";
+
+        // Step 1: ProofBuilder creates a CID (hex decoding is case-insensitive)
+        let tx_cid = simulate_proof_builder_tx_hash_to_cid(mixed_case_tx_hash);
+
+        // Step 2: Validation converts CID back to tx_hash for lookup
+        let lookup_tx_hash = tx_hash_try_from_cid(tx_cid).unwrap().to_string();
+
+        // Step 3: The lookup should produce lowercase (TxHash::to_string() uses lowercase)
+        assert_eq!(
+            lookup_tx_hash, "0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890",
+            "Mixed-case input should normalize to lowercase for lookup"
+        );
+
+        // Step 4: Verify case-insensitive equality with original
+        assert_eq!(
+            mixed_case_tx_hash.to_lowercase(),
+            lookup_tx_hash,
+            "Normalized tx_hash must match original (case-insensitive)"
+        );
+    }
+}
diff --git a/event-svc/src/event/service.rs b/event-svc/src/event/service.rs
@@ -545,7 +545,7 @@ impl EventService {
 
     /// Get the chain proof for a given event from the database.
     /// All proofs should have been validated and stored during the event validation phase (v0.55.0+).
-    async fn discover_chain_proof(
+    pub(crate) async fn discover_chain_proof(
         &self,
         event: &ceramic_event::unvalidated::TimeEvent,
     ) -> std::result::Result<ChainProof, crate::eth_rpc::Error> {
@@ -556,6 +556,9 @@ impl EventService {
             .await
             .map_err(|e| crate::eth_rpc::Error::Application(e.into()))?
             .ok_or_else(|| {
+                // Note: Using InvalidProof here rather than TxNotFound because:
+                // - TxNotFound is for "transaction not found on blockchain" (RPC-level)
+                // - This is "proof not in local database" (local storage issue)
                 crate::eth_rpc::Error::InvalidProof(format!(
                     "Chain proof for tx {} not found in database.",
                     tx_hash
diff --git a/event-svc/src/event/store.rs b/event-svc/src/event/store.rs
@@ -267,6 +267,13 @@ impl ceramic_anchor_service::Store for EventService {
         // Persist chain inclusion proof FIRST for self-anchored events.
         // This aligns with the external event flow (service.rs persists proofs before events)
         // and ensures events are never orphaned without their chain proofs.
+        //
+        // NOTE: These operations are NOT wrapped in a single transaction. Failure scenarios:
+        // - If proof persistence fails: early return, no events inserted (safe)
+        // - If proof succeeds but event insertion fails: orphaned proof remains in DB
+        //   This is acceptable because:
+        //   1. Orphaned proofs are harmless (just extra data, no foreign key constraints)
+        //   2. The proof can be used if the events are retried later
         if let Some(chain_data) = chain_inclusion {
             let proof: ChainProof = chain_data.into();
             self.event_access
diff --git a/event-svc/src/store/sql/entities/chain_proof.rs b/event-svc/src/store/sql/entities/chain_proof.rs
@@ -46,3 +46,70 @@ impl From<ceramic_anchor_service::ChainInclusionData> for ChainProof {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use ceramic_anchor_service::ChainInclusionData;
+
+    #[test]
+    fn test_chain_proof_from_chain_inclusion_data() {
+        let data = ChainInclusionData {
+            chain_id: "eip155:100".to_string(),
+            transaction_hash: "0xabc123def456abc123def456abc123def456abc123def456abc123def456abc1"
+                .to_string(),
+            transaction_input: "0x97ad09eb1234567890abcdef1234567890abcdef1234567890abcdef12345678"
+                .to_string(),
+            block_hash: "0xdef456abc123def456abc123def456abc123def456abc123def456abc123def4"
+                .to_string(),
+            timestamp: 1704067200,
+        };
+
+        let proof: ChainProof = data.into();
+
+        assert_eq!(proof.chain_id, "eip155:100");
+        assert_eq!(
+            proof.transaction_hash,
+            "0xabc123def456abc123def456abc123def456abc123def456abc123def456abc1"
+        );
+        assert_eq!(
+            proof.transaction_input,
+            "0x97ad09eb1234567890abcdef1234567890abcdef1234567890abcdef12345678"
+        );
+        assert_eq!(
+            proof.block_hash,
+            "0xdef456abc123def456abc123def456abc123def456abc123def456abc123def4"
+        );
+        assert_eq!(proof.timestamp, 1704067200);
+    }
+
+    #[test]
+    fn test_chain_proof_from_chain_inclusion_data_preserves_chain_id_format() {
+        for chain_id in ["eip155:1", "eip155:100", "eip155:137", "eip155:42161"] {
+            let data = ChainInclusionData {
+                chain_id: chain_id.to_string(),
+                transaction_hash: "0x".to_string() + &"a".repeat(64),
+                transaction_input: "0x".to_string() + &"b".repeat(72),
+                block_hash: "0x".to_string() + &"c".repeat(64),
+                timestamp: 1704067200,
+            };
+
+            let proof: ChainProof = data.into();
+            assert_eq!(proof.chain_id, chain_id);
+        }
+    }
+
+    #[test]
+    fn test_chain_proof_timestamp_zero() {
+        let data = ChainInclusionData {
+            chain_id: "eip155:1".to_string(),
+            transaction_hash: "0x".to_string() + &"a".repeat(64),
+            transaction_input: "0x".to_string() + &"b".repeat(72),
+            block_hash: "0x".to_string() + &"c".repeat(64),
+            timestamp: 0,
+        };
+
+        let proof: ChainProof = data.into();
+        assert_eq!(proof.timestamp, 0);
+    }
+}
diff --git a/event-svc/src/tests/mod.rs b/event-svc/src/tests/mod.rs
@@ -1,6 +1,7 @@
 mod event;
 mod migration;
 mod ordering;
+mod self_anchor;
 
 use std::{str::FromStr, sync::Arc};
 
diff --git a/event-svc/src/tests/self_anchor.rs b/event-svc/src/tests/self_anchor.rs
