💨 Direct Air Capture Simulator

// Calculate sorbent efficiency and lifetime
function calculateSorbentEfficiency(params) {
  const {
    co2Captured,        // tons of CO2 captured
    sorbentMass,        // kg of sorbent material
    cycleNumber,        // current adsorption cycle
    regenerationTemp,   // °C
    ambientCO2          // ppm
  } = params;

  // Sorbent loading capacity (decreases with cycles)
  const degradationFactor = Math.exp(-0.0001 * cycleNumber);
  const maxLoading = 3.5; // mmol CO2/g sorbent
  const currentLoading = maxLoading * degradationFactor;

  // Capture efficiency
  const theoreticalCapture = (sorbentMass * currentLoading * 44) / 1e6;
  const efficiency = (co2Captured / theoreticalCapture) * 100;

  // Energy for regeneration (kJ/kg sorbent)
  const regenerationEnergy = 150 + (regenerationTemp - 80) * 2;

  // Estimated remaining lifetime
  const maxCycles = 10000;
  const remainingCycles = maxCycles - cycleNumber;
  const remainingLifetime = remainingCycles * 0.5; // days (2 cycles/day)

  return {
    currentLoading: currentLoading.toFixed(2),
    efficiency: efficiency.toFixed(2),
    regenerationEnergy: regenerationEnergy.toFixed(2),
    remainingLifetime: Math.floor(remainingLifetime),
    degradation: ((1 - degradationFactor) * 100).toFixed(2)
  };
}

// Optimize capture rate based on conditions
function optimizeCaptureRate(conditions) {
  const {
    ambientCO2,      // ppm
    temperature,     // °C
    humidity,        // %
    airflow,         // m³/min
    energyCost       // $/kWh
  } = conditions;

  // Optimal operating parameters
  const optimalTemp = 20; // °C
  const optimalHumidity = 60; // %
  const optimalAirflow = 5000; // m³/min

  // Calculate efficiency factors
  const tempFactor = 1 - Math.abs(temperature - optimalTemp) * 0.02;
  const humidityFactor = 1 - Math.abs(humidity - optimalHumidity) * 0.005;
  const airflowFactor = Math.min(airflow / optimalAirflow, 1.2);

  // Overall efficiency
  const efficiency = tempFactor * humidityFactor * airflowFactor;

  // CO2 capture rate (kg/hour)
  const baseCaptureRate = 50; // kg/hour
  const actualCaptureRate = baseCaptureRate * efficiency;

  // Energy optimization
  const baseEnergy = 300; // kWh/ton CO2
  const energyPerTon = baseEnergy / efficiency;
  const costPerTon = energyPerTon * energyCost;

  return {
    efficiency: (efficiency * 100).toFixed(2),
    captureRate: actualCaptureRate.toFixed(2),
    energyPerTon: energyPerTon.toFixed(2),
    costPerTon: costPerTon.toFixed(2),
    recommendations: getRecommendations(conditions)
  };
}

function getRecommendations(conditions) {
  const recommendations = [];
  if (conditions.temperature > 25) {
    recommendations.push("Consider cooling to improve efficiency");
  }
  if (conditions.humidity < 40) {
    recommendations.push("Low humidity may reduce sorbent performance");
  }
  if (conditions.airflow < 4000) {
    recommendations.push("Increase airflow for better capture rate");
  }
  return recommendations;
}

PROTOCOL: DAC-CAPTURE-001
Version: 1.0

1. PRE-OPERATION CHECKS
   - Verify sorbent condition (saturation < 90%)
   - Check energy supply (renewable source confirmed)
   - Validate ambient conditions (temp, humidity, CO2)
   - Test airflow systems (target: 5000 m³/min)

2. CAPTURE CYCLE
   - Duration: 8-12 hours
   - Air intake through contactor
   - CO2 adsorption onto sorbent material
   - Monitor: CO2 concentration, flow rate, pressure drop
   - Log: timestamp, capture rate, energy consumption

3. REGENERATION CYCLE
   - Heat sorbent to release CO2
   - Temperature: 80-120°C (depending on sorbent type)
   - Duration: 2-4 hours
   - Collect concentrated CO2 stream (>95% purity)
   - Cool sorbent for next cycle

4. QUALITY CONTROL
   - Verify CO2 purity (must be >95%)
   - Measure capture efficiency (target >90%)
   - Check for contaminants (water vapor, nitrogen oxides)
   - Record sorbent degradation metrics

5. DATA RECORDING
   - Timestamp all measurements
   - Log energy consumption per ton CO2
   - Record environmental conditions
   - Update facility dashboard

6. SAFETY PROTOCOLS
   - Monitor for CO2 leaks
   - Maintain proper ventilation
   - Emergency shutdown procedures
   - Personnel protective equipment requirements

PROTOCOL: DAC-STORAGE-001
Version: 1.0

1. STORAGE METHOD SELECTION

   A. GEOLOGICAL STORAGE
      - Deep saline aquifers (800-2000m depth)
      - Depleted oil/gas reservoirs
      - Requires: Caprock integrity, injectivity tests

   B. MINERALIZATION (Recommended)
      - React CO2 with basalt rock
      - CarbFix method: 90% mineralization in 2 years
      - Permanent storage (>10,000 years)

   C. UTILIZATION
      - Convert to synthetic fuels
      - Building materials (concrete curing)
      - Enhanced oil recovery (EOR)

2. INJECTION PROCESS
   - Compress CO2 to supercritical state (>31°C, >73 bar)
   - Pipeline transport to injection site
   - Inject at controlled rate (50-100 tons/day)
   - Monitor injection pressure and temperature

3. MONITORING & VERIFICATION
   - Continuous pressure monitoring
   - Seismic surveys (annually)
   - Groundwater sampling (quarterly)
   - Atmospheric CO2 monitoring above site
   - Satellite InSAR for surface deformation

4. VERIFICATION WORKFLOW
   - Third-party verification required
   - MRV (Monitoring, Reporting, Verification)
   - ISO 27916 compliance (CCS)
   - Generate verifiable credentials
   - Issue carbon removal certificates

5. PERMANENCE GUARANTEE
   - Minimum storage period: 1000 years
   - Insurance requirements
   - Long-term monitoring plan
   - Liability transfer protocols

┌─────────────────────────────────────────────────────────────┐
│                    DAC FACILITY                              │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐                  │
│  │  Air     │→ │ Sorbent  │→ │   CO2    │                  │
│  │ Intake   │  │ Contactor│  │ Release  │                  │
│  └──────────┘  └──────────┘  └─────┬────┘                  │
└────────────────────────────────────┼────────────────────────┘
                                     │
                         ┌───────────▼──────────┐
                         │  CO2 Compression     │
                         │  (Supercritical)     │
                         └───────────┬──────────┘
                                     │
                         ┌───────────▼──────────┐
                         │  Pipeline Transport  │
                         └───────────┬──────────┘
                                     │
        ┌────────────────────────────┼────────────────────────┐
        │                            │                        │
   ┌────▼─────┐              ┌──────▼──────┐        ┌───────▼────┐
   │ CarbFix  │              │  Geological │        │   CO2      │
   │ Mineral. │              │   Storage   │        │ Utilization│
   └────┬─────┘              └──────┬──────┘        └───────┬────┘
        │                           │                       │
        └───────────────┬───────────┴───────────────────────┘
                        │
                ┌───────▼────────┐
                │  MRV System    │
                │  - Monitoring  │
                │  - Reporting   │
                │  - Verification│
                └───────┬────────┘
                        │
                ┌───────▼────────┐
                │  Carbon Credit │
                │   Registry     │
                └────────────────┘

// DAC to Storage Facility Integration
class DACStorageIntegration {
  constructor(facilityId, storageEndpoint) {
    this.facilityId = facilityId;
    this.storageEndpoint = storageEndpoint;
    this.apiKey = process.env.STORAGE_API_KEY;
  }

  // Submit captured CO2 for storage
  async submitCO2(captureData) {
    const payload = {
      facilityId: this.facilityId,
      timestamp: new Date().toISOString(),
      co2Amount: captureData.amount, // tons
      purity: captureData.purity, // percentage
      temperature: captureData.temperature,
      pressure: captureData.pressure,
      storageMethod: captureData.storageMethod,
      certificationRequired: true
    };

    const response = await fetch(
      `${this.storageEndpoint}/api/v1/inject`,
      {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${this.apiKey}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify(payload)
      }
    );

    return await response.json();
  }

  // Get storage verification
  async getVerification(injectionId) {
    const response = await fetch(
      `${this.storageEndpoint}/api/v1/verify/${injectionId}`,
      {
        headers: {
          'Authorization': `Bearer ${this.apiKey}`
        }
      }
    );

    const verification = await response.json();
    return {
      injectionId: verification.id,
      status: verification.status,
      permanence: verification.permanenceYears,
      certificate: verification.certificateUrl,
      carbonCredits: verification.creditsIssued
    };
  }

  // Real-time monitoring data stream
  async streamMonitoring() {
    const ws = new WebSocket(
      `${this.storageEndpoint}/ws/monitoring/${this.facilityId}`
    );

    ws.on('message', (data) => {
      const metrics = JSON.parse(data);
      console.log('Storage metrics:', metrics);
      // Update dashboard, trigger alerts, etc.
    });
  }
}

{
  "@context": [
    "https://www.w3.org/2018/credentials/v1",
    "https://wia.org/credentials/dac/v1"
  ],
  "type": ["VerifiableCredential", "CarbonRemovalCertificate"],
  "issuer": {
    "id": "did:wia:dac-climeworks-001",
    "name": "Orca DAC Facility",
    "certifications": ["ISO 27916", "ISO 14064-2"]
  },
  "issuanceDate": "2025-12-25T00:00:00Z",
  "expirationDate": null,
  "credentialSubject": {
    "id": "did:wia:capture:2025-12-25-001",
    "type": "CarbonRemoval",
    "amount": {
      "value": 10.5,
      "unit": "tons CO2"
    },
    "captureDate": "2025-12-25",
    "technology": {
      "type": "solid-sorbent-dac",
      "manufacturer": "Climeworks",
      "efficiency": 0.92
    },
    "storage": {
      "method": "mineralization",
      "site": "carbfix-hellisheidi",
      "permanence": "permanent",
      "verifiedBy": "DNV GL"
    },
    "energy": {
      "source": "geothermal",
      "renewable": true,
      "specificConsumption": "2.4 MWh/ton CO2"
    },
    "verification": {
      "standard": "ISO 27916",
      "verifier": "Bureau Veritas",
      "verificationDate": "2025-12-26",
      "reportUrl": "https://verify.wia.org/dac/2025-12-25-001"
    },
    "carbonCredits": {
      "registry": "Puro.earth",
      "serialNumber": "PURO-DAC-2025-12-001",
      "vintage": 2025,
      "status": "active"
    }
  },
  "proof": {
    "type": "Ed25519Signature2020",
    "created": "2025-12-26T08:00:00Z",
    "verificationMethod": "did:wia:dac-climeworks-001#key-1",
    "proofPurpose": "assertionMethod",
    "proofValue": "z5A3k2b..."
  }
}

// Generate QR code for carbon removal certificate
function generateCertificateQR(certificateData) {
  const qrData = {
    type: "WIA-ENE-050-Certificate",
    version: "1.0",
    certificateId: certificateData.id,
    facilityId: certificateData.facilityId,
    co2Removed: certificateData.amount,
    date: certificateData.date,
    verificationUrl: `https://verify.wia.org/dac/${certificateData.id}`,
    vcUrl: `https://credentials.wia.org/dac/${certificateData.id}.json`
  };

  // Encode as JSON string
  const qrString = JSON.stringify(qrData);

  // Generate QR code (using library like qrcode.js)
  const qrCode = QRCode.toDataURL(qrString, {
    errorCorrectionLevel: 'H',
    type: 'image/png',
    width: 512,
    color: {
      dark: '#EF4444',  // WIA-ENE color
      light: '#0f172a'   // Background
    }
  });

  return qrCode;
}

// Verify certificate from QR code scan
async function verifyCertificate(qrData) {
  const data = JSON.parse(qrData);

  // Fetch verifiable credential
  const vcResponse = await fetch(data.vcUrl);
  const vc = await vcResponse.json();

  // Verify digital signature
  const isValid = await verifySignature(vc);

  // Check against registry
  const registryStatus = await checkRegistry(
    vc.credentialSubject.carbonCredits.serialNumber
  );

  return {
    valid: isValid && registryStatus.active,
    certificate: vc,
    registryStatus: registryStatus
  };
}

// Carbon credit lifecycle tracking
class CarbonCreditTracker {
  constructor(registryAPI) {
    this.registry = registryAPI;
  }

  // Issue credits after verification
  async issueCredits(captureData) {
    const credits = {
      serialNumber: this.generateSerialNumber(),
      vintage: new Date().getFullYear(),
      amount: captureData.co2Amount,
      methodology: "Puro.earth CDR",
      project: captureData.facilityId,
      status: "issued",
      issued: new Date().toISOString(),
      permanence: captureData.permanenceYears,
      cobenefits: [
        "climate-mitigation",
        "renewable-energy-use",
        "sustainable-development"
      ]
    };

    await this.registry.issue(credits);
    return credits;
  }

  // Transfer credits (for sale/retirement)
  async transferCredits(serialNumber, toAccount, purpose) {
    const transfer = {
      from: this.account,
      to: toAccount,
      serialNumber: serialNumber,
      purpose: purpose, // "sale" or "retirement"
      timestamp: new Date().toISOString()
    };

    if (purpose === "retirement") {
      // Permanent retirement for offsetting
      await this.registry.retire(transfer);
    } else {
      // Transfer ownership
      await this.registry.transfer(transfer);
    }

    return transfer;
  }

  // Get credit provenance
  async getProvenance(serialNumber) {
    const history = await this.registry.getHistory(serialNumber);

    return {
      serialNumber: serialNumber,
      issuance: history.issuance,
      transfers: history.transfers,
      currentOwner: history.currentOwner,
      status: history.status,
      verificationTrail: history.verifications
    };
  }
}