Skip to main content

Use Cases

Real-world applications for L{CORE}'s decentralized IoT attestation infrastructure.

DePIN & IoT Networks​

Environmental Monitoring Networks​

Problem: DePIN projects need verifiable proof that sensors are real and readings are authentic—not spoofed data from bad actors.

Solution: L{CORE} provides cryptographic device attestation:

  • Each sensor has a did:key identity
  • Readings signed at the device level
  • Reclaim's TEE verifies signatures before on-chain submission
  • Impossible to spoof without the device's private key
from lcore import LCore, DeviceIdentity

device = DeviceIdentity.generate()  # did:key:z6Mk...

async with LCore(attestor_url="...", cartesi_url="...") as lcore:
    result = await lcore.submit_device_data(
        device=device,
        payload={
            "temperature": 23.4,
            "humidity": 65.0,
            "pm25": 12.3,
            "location_hash": "geohash:9q8yy"
        }
    )

Smart City Sensor Networks​

Problem: Cities deploying IoT infrastructure need auditable, tamper-evident data for traffic, air quality, and infrastructure monitoring.

Solution: Decentralized attestation for municipal IoT:

  • Traffic counters with verifiable readings
  • Air quality sensors with cryptographic provenance
  • Infrastructure health monitoring with device-level signatures
  • All data queryable on-chain with fraud proofs

Supply Chain & Logistics​

Cold Chain Monitoring​

Problem: Pharmaceutical and food supply chains need cryptographic proof of temperature compliance—not just logs that can be edited.

Solution: IoT sensors attest temperature readings at the source:

const result = await lcore.attest({
  provider: 'iot',
  params: {
    deviceId: 'coldchain-sensor-001',
    dataType: 'temperature',
    bucketDefinition: {
      boundaries: [-20, 0, 4, 8, 25, 40],
      labels: ['frozen', 'cold', 'refrigerated', 'cool', 'room-temp', 'hot']
    }
  }
})
  • Sensor signs each reading with did:key
  • "Refrigerated" bucket proves compliance without exact temps
  • Smart contract triggers insurance if conditions violated
  • Full audit trail with device provenance

Asset Tracking & Geofencing​

Problem: Prove cargo location for insurance and compliance without revealing trade routes.

Solution: Privacy-preserving location attestation:

  • "In transit: US West Coast" not exact GPS coordinates
  • Geofence compliance without revealing routes
  • Device-signed location proofs
  • Customs compliance with minimal data exposure

Industrial IoT​

Manufacturing Quality Control​

Problem: Manufacturers need auditable sensor data for compliance certifications (ISO, FDA) but can't trust centralized logging.

Solution: Verifiable machine attestation:

  • Production line sensors sign quality metrics
  • Timestamps cryptographically verified
  • Compliance data stored on-chain with fraud proofs
  • Auditors query Cartesi directly—no trust required

Predictive Maintenance​

Problem: Insurance and warranty providers need verified equipment telemetry.

Solution: Machine health attestation:

result = await lcore.submit_device_data(
    device=machine_identity,
    payload={
        "vibration_level": "normal",  # bucketed
        "operating_hours": 1250,
        "temperature_status": "within_spec",
        "maintenance_due": False
    }
)
  • Prove equipment was maintained per spec
  • Warranty claims backed by device-signed data
  • Insurance underwriting with verified telemetry

Energy & Utilities​

Renewable Energy Certification​

Problem: RECs (Renewable Energy Certificates) need verifiable proof of generation from actual solar/wind installations.

Solution: Energy meter attestation:

  • Smart meters sign generation readings
  • Device identity tied to physical installation
  • Grid injection verified at the source
  • Carbon credits backed by cryptographic proofs

Grid Balancing & Demand Response​

Problem: Distributed energy resources need verifiable participation in demand response programs.

Solution: Load attestation:

  • Smart plugs/meters attest consumption changes
  • Participation verified with device signatures
  • Automated incentive distribution via smart contracts

Agriculture & Food Safety​

Farm-to-Table Traceability​

Problem: Consumers and regulators want verified provenance, but current systems rely on trust.

Solution: Agricultural IoT attestation:

  • Soil sensors attest growing conditions
  • Harvest timestamps device-signed
  • Storage conditions verified through cold chain
  • Full provenance from field to shelf

Organic & Sustainability Certification​

Problem: Certification fraud undermines consumer trust.

Solution: Sensor-verified compliance:

  • Pesticide/fertilizer application (or lack thereof) attested
  • Water usage monitored and verified
  • Certifications backed by device data, not paperwork

Healthcare IoT​

Medical Device Data​

Problem: Remote patient monitoring needs verified data for clinical decisions and insurance.

Solution: Medical IoT attestation with privacy:

  • Glucose monitors, heart rate sensors sign readings
  • Privacy buckets: "Blood glucose: Normal range"
  • HIPAA-compatible—no raw data on-chain
  • Patient controls decryption keys

Clinical Trial Data Integrity​

Problem: Trial data integrity is crucial but current systems are centralized and auditable only by sponsors.

Solution: Decentralized trial data attestation:

  • Wearable devices attest participant data
  • Timestamps verified at the source
  • Auditors verify on-chain without sponsor access
  • Fraud-proof data integrity

Implementation Patterns​

Pattern 1: Direct Device Attestation (Python/C)​

For sensors and embedded devices:

from lcore import LCore, DeviceIdentity

# One-time device setup
device = DeviceIdentity.generate()
device.save("~/.lcore_device.json")

# Continuous attestation
async with LCore(attestor_url="...", cartesi_url="...") as lcore:
    while True:
        reading = sensor.read()
        await lcore.submit_device_data(
            device=device,
            payload=reading
        )
        await asyncio.sleep(60)

Pattern 2: Gateway Aggregation (TypeScript)​

For multiple sensors through a gateway:

import { LCore, DeviceRegistry } from '@locale/lcore-sdk'

const gateway = new LCore({ attestorUrl, cartesiUrl })
const devices = new DeviceRegistry('./devices/')

// Aggregate and attest sensor data
for (const device of devices.all()) {
  const reading = await device.read()
  await gateway.submitDeviceData({
    device: device.identity,
    payload: reading
  })
}

Pattern 3: Privacy Buckets for Compliance​

When exact values shouldn't be stored:

const result = await lcore.attest({
  provider: 'iot',
  params: {
    deviceId: 'temp-sensor-001',
    bucketDefinition: {
      field: 'temperature',
      boundaries: [0, 4, 8, 15, 25],
      labels: ['frozen', 'refrigerated', 'cold', 'cool', 'ambient']
    }
  }
})
// Stores "refrigerated" not "6.3°C"

Why L{CORE} for IoT?​

ChallengeL{CORE} Solution
Device spoofingdid:key signatures at device level
Centralized oraclesSelf-hosted attestors on Reclaim's TEE infra
Data tamperingCartesi fraud proofs
Privacy concernsBucketing and encryption
Vendor lock-inChain-agnostic, self-sovereign

Next Steps​