IoTeX - The Leading Blockchain for IoT and DePIN

// Device registration contract
const DeviceRegistry = {
  // Register new IoT device
  async registerDevice(deviceId, metadata) {
    const tx = await contract.registerDevice(
      deviceId,
      metadata.manufacturer,
      metadata.model,
      metadata.location,
      { gasLimit: 100000 }
    );
    return tx.wait();
  },

  // Update device status
  async updateDeviceStatus(deviceId, status, timestamp) {
    const signature = await signDeviceData(deviceId, status, timestamp);
    return contract.updateStatus(deviceId, status, timestamp, signature);
  },

  // Query device history
  async getDeviceHistory(deviceId, fromBlock = 0) {
    const filter = contract.filters.DeviceUpdate(deviceId);
    return contract.queryFilter(filter, fromBlock);
  }
};

// W3bstream integration for IoT data
class W3bstreamProcessor {
  constructor(endpoint) {
    this.endpoint = endpoint;
    this.provider = new JsonRpcProvider(
      'https://api-iotex-mainnet.n.dwellir.com/YOUR_API_KEY'
    );
  }

  // Submit IoT data for processing
  async submitData(deviceId, data) {
    // Create data proof
    const proof = await this.createProof(deviceId, data);

    // Submit to W3bstream
    const result = await fetch(`${this.endpoint}/submit`, {
      method: 'POST',
      body: JSON.stringify({
        deviceId,
        data,
        proof,
        timestamp: Date.now()
      })
    });

    // Store proof on-chain
    const tx = await this.storeProof(proof);
    return { proofId: tx.hash, result: await result.json() };
  }

  // Verify data authenticity
  async verifyData(proofId) {
    const proof = await this.contract.getProof(proofId);
    return this.verifyProof(proof);
  }
}

// DePIN node management
const DePINManager = {
  // Register infrastructure node
  async registerNode(nodeInfo) {
    const stake = ethers.parseEther('1000'); // Minimum stake

    const tx = await contract.registerNode(
      nodeInfo.id,
      nodeInfo.type, // 'sensor', 'gateway', 'compute'
      nodeInfo.location,
      nodeInfo.capabilities,
      { value: stake }
    );

    return tx.wait();
  },

  // Submit proof of work
  async submitProofOfWork(nodeId, data) {
    const proof = await generateWorkProof(nodeId, data);
    return contract.submitProof(nodeId, proof);
  },

  // Claim rewards
  async claimRewards(nodeId) {
    const rewards = await contract.pendingRewards(nodeId);
    if (rewards > 0) {
      return contract.claimRewards(nodeId);
    }
  }
};

class BatchProcessor {
  constructor() {
    this.batch = [];
    this.batchSize = 100;
  }

  async addReading(deviceId, data) {
    this.batch.push({ deviceId, data, timestamp: Date.now() });

    if (this.batch.length >= this.batchSize) {
      await this.submitBatch();
    }
  }

  async submitBatch() {
    if (this.batch.length === 0) return;

    const merkleRoot = this.calculateMerkleRoot(this.batch);

    // Submit only merkle root on-chain
    const tx = await contract.submitBatch(
      merkleRoot,
      this.batch.length,
      { gasLimit: 200000 }
    );

    // Store full data off-chain
    await this.storeOffchain(this.batch, tx.hash);

    this.batch = [];
    return tx;
  }
}

class DeviceConnectionPool {
  constructor(maxConnections = 100) {
    this.pool = new Map();
    this.maxConnections = maxConnections;
  }

  async getConnection(deviceId) {
    if (!this.pool.has(deviceId)) {
      if (this.pool.size >= this.maxConnections) {
        this.evictOldest();
      }

      const connection = await this.createConnection(deviceId);
      this.pool.set(deviceId, {
        connection,
        lastUsed: Date.now()
      });
    }

    const poolEntry = this.pool.get(deviceId);
    poolEntry.lastUsed = Date.now();
    return poolEntry.connection;
  }

  evictOldest() {
    let oldest = Date.now();
    let oldestId = null;

    for (const [id, entry] of this.pool.entries()) {
      if (entry.lastUsed < oldest) {
        oldest = entry.lastUsed;
        oldestId = id;
      }
    }

    if (oldestId) {
      this.pool.delete(oldestId);
    }
  }
}

class EventMonitor {
  constructor(provider) {
    this.provider = provider;
    this.filters = new Map();
  }

  async watchDevice(deviceId, callback) {
    // Create optimized filter
    const filter = {
      address: CONTRACT_ADDRESS,
      topics: [
        ethers.id('DeviceUpdate(string,uint256,bytes32)'),
        ethers.id(deviceId)
      ]
    };

    // Use WebSocket for real-time updates
    this.provider.on(filter, async (log) => {
      const parsed = this.parseLog(log);
      await callback(parsed);
    });

    this.filters.set(deviceId, filter);
  }

  stopWatching(deviceId) {
    const filter = this.filters.get(deviceId);
    if (filter) {
      this.provider.off(filter);
      this.filters.delete(deviceId);
    }
  }
}

async function ensureDeviceRegistered(deviceId) {
  try {
    const device = await contract.getDevice(deviceId);
    return device.isActive;
  } catch (error) {
    if (error.message.includes('Device not found')) {
      // Auto-register device
      await contract.registerDevice(
        deviceId,
        DEFAULT_METADATA,
        { gasLimit: 150000 }
      );
      return true;
    }
    throw error;
  }
}

function validateSensorData(data) {
  const required = ['deviceId', 'timestamp', 'value'];

  for (const field of required) {
    if (!data[field]) {
      throw new Error(`Missing required field: ${field}`);
    }
  }

  // Validate timestamp is recent (within 5 minutes)
  const fiveMinutes = 5 * 60 * 1000;
  if (Date.now() - data.timestamp > fiveMinutes) {
    throw new Error('Timestamp too old');
  }

  // Validate value ranges
  if (data.value < MIN_VALUE || data.value > MAX_VALUE) {
    throw new Error('Value out of range');
  }

  return true;
}

async function submitWithRetry(data, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      const proof = await w3bstream.generateProof(data);
      const tx = await contract.submitProof(proof);
      return tx;
    } catch (error) {
      if (error.message.includes('proof verification')) {
        // Regenerate proof with fresh nonce
        data.nonce = Date.now();
        continue;
      }
      throw error;
    }
  }
  throw new Error('Failed to submit proof after retries');
}

// Before (Ethereum)
const provider = new JsonRpcProvider('https://eth-mainnet.example.com');
const contract = new Contract(address, abi, provider);

// After (IoTeX)
const provider = new JsonRpcProvider(
  'https://api-iotex-mainnet.n.dwellir.com/YOUR_API_KEY'
);
const contract = new Contract(address, abi, provider);

// All Ethereum tools work
// Same development workflow
// Additional IoT capabilities
// Note: Different chain ID (4689)
// Note: IOTX as gas token (not ETH)
// Access to W3bstream and MachineFi

// Device SDK integration
import { IoTeXDevice } from '@iotex/device-sdk';

const device = new IoTeXDevice({
  deviceId: 'sensor_001',
  privateKey: process.env.DEVICE_KEY,
  endpoint: 'https://api-iotex-mainnet.n.dwellir.com/YOUR_API_KEY'
});

// Auto-submit sensor readings
device.on('reading', async (data) => {
  await device.submitToBlockchain(data);
});

// Start monitoring
device.startMonitoring({
  interval: 60000, // Every minute
  sensors: ['temperature', 'humidity']
});