Fix CI pipeline errors

Rust fixes:
- Rename UnitType::from_str to parse_unit_type (avoid std trait confusion)
- Fix unwrap after is_some check with proper if-let pattern
- Replace vec! with array for static data (clippy suggestion)

Solidity fixes:
- Remove problematic OpenZeppelin certora files in CI workflow
- Fix PipeEscrow test to use new initialize(consumer, provider) signature
- All 8 contract tests now pass

CI should now pass completely for both Rust and Solidity.

Author: boorich

.github/workflows/ci.yml

@@ -54,15 +54,24 @@ jobs:
 
       - name: Build contracts
         working-directory: contracts
-        run: forge build
+        run: |
+          # Remove problematic certora files that reference missing patched files
+          rm -rf lib/openzeppelin-contracts/certora
+          forge build
       
       - name: Run tests
         working-directory: contracts
-        run: forge test -vv
+        run: |
+          # Remove problematic certora files that reference missing patched files
+          rm -rf lib/openzeppelin-contracts/certora
+          forge test -vv
       
       - name: Coverage
         working-directory: contracts
-        run: forge coverage
+        run: |
+          # Remove problematic certora files that reference missing patched files
+          rm -rf lib/openzeppelin-contracts/certora
+          forge coverage
 
 
 

contracts/PipeEscrow.t.sol

@@ -21,8 +21,7 @@ contract PipeEscrowTest is Test {
 
         pipe = new PipeEscrow();
 
-        vm.prank(consumer);
-        pipe.initialize(provider);
+        pipe.initialize(consumer, provider);
     }
 
     function testInitialize() public {

contracts/foundry.toml

@@ -7,11 +7,20 @@ optimizer = true
 optimizer_runs = 200
 via_ir = false
 
-# Exclude OpenZeppelin's test/mock/certora files
+# Only compile our contracts and core OpenZeppelin contracts
+include = [
+    "*.sol",
+    "lib/openzeppelin-contracts/contracts/**/*.sol",
+    "lib/forge-std/src/**/*.sol",
+    "lib/ds-test/src/**/*.sol",
+]
+
+# Exclude problematic OpenZeppelin files
 exclude = [
     "lib/openzeppelin-contracts/certora/**",
     "lib/openzeppelin-contracts/test/**", 
     "lib/openzeppelin-contracts/mocks/**",
+    "lib/openzeppelin-contracts/lib/**",
     "node_modules/**",
 ]
 

src/daemon.rs

@@ -223,7 +223,7 @@ async fn serve_stream(
 
     // For streaming, we'll simulate sending data in chunks
     // In a real implementation, this would stream actual data
-    let chunks = vec![
+    let chunks = [
         "Chunk 1: Starting data stream...\n",
         "Chunk 2: Processing your request...\n",
         "Chunk 3: Generating response...\n",

src/units.rs

@@ -37,7 +37,7 @@ impl fmt::Display for UnitType {
 
 impl UnitType {
     /// Parse unit type from string (case insensitive)
-    pub fn from_str(s: &str) -> Self {
+    pub fn parse_unit_type(s: &str) -> Self {
         match s.to_lowercase().as_str() {
             "bytes" | "byte" => UnitType::Bytes,
             "tokens" | "token" => UnitType::Tokens,
@@ -122,7 +122,7 @@ impl X402Headers {
         // Parse unit type
         if let Some(unit_type) = headers.get("x402-unit-type") {
             if let Ok(unit_str) = unit_type.to_str() {
-                x402.unit_type = Some(UnitType::from_str(unit_str));
+                x402.unit_type = Some(UnitType::parse_unit_type(unit_str));
             }
         }
 
@@ -189,10 +189,14 @@ impl ConsumptionTracker {
 
     /// Update consumption based on x402 headers or data size
     pub fn update_consumption(&mut self, headers: &X402Headers, data_size: usize) -> f64 {
-        if self.provider_pricing && headers.units_consumed.is_some() {
-            // Use provider-specified consumption
-            let units = headers.units_consumed.unwrap();
-            self.unit.consume(units)
+        if self.provider_pricing {
+            if let Some(units) = headers.units_consumed {
+                // Use provider-specified consumption
+                self.unit.consume(units)
+            } else {
+                // Fallback to byte-based consumption
+                self.unit.consume(data_size as u64)
+            }
         } else {
             // Fallback to byte-based consumption
             self.unit.consume(data_size as u64)
@@ -403,10 +407,10 @@ mod tests {
 
     #[test]
     fn test_unit_type_parsing() {
-        assert_eq!(UnitType::from_str("bytes"), UnitType::Bytes);
-        assert_eq!(UnitType::from_str("TOKENS"), UnitType::Tokens);
+        assert_eq!(UnitType::parse_unit_type("bytes"), UnitType::Bytes);
+        assert_eq!(UnitType::parse_unit_type("TOKENS"), UnitType::Tokens);
         assert_eq!(
-            UnitType::from_str("custom-unit"),
+            UnitType::parse_unit_type("custom-unit"),
             UnitType::Custom("custom-unit".to_string())
         );
     }