IoTeX RPC Node
Blockchain for IoT

const { ethers } = require('ethers');

const provider = new ethers.JsonRpcProvider('https://rpc.crypto-chief.com/iotex/YOUR_API_KEY');

// Verify connection to IoTeX
const network = await provider.getNetwork();
console.log('Chain ID:', network.chainId); // 4689
console.log('Network:', network.name); // iotex

// Device registry smart contract
const DEVICE_REGISTRY = '0x...';
const deviceRegistryABI = [
  'function registerDevice(bytes32 deviceId, bytes publicKey, string metadata) external',
  'function publishData(bytes32 deviceId, bytes data, bytes signature) external',
  'function verifyDevice(bytes32 deviceId) view returns (bool)',
  'function getDeviceInfo(bytes32 deviceId) view returns (tuple(address owner, bytes publicKey, bool active, uint256 registeredAt))'
];

const registry = new ethers.Contract(DEVICE_REGISTRY, deviceRegistryABI, wallet);

// Register IoT device on blockchain
const deviceId = ethers.keccak256(ethers.toUtf8Bytes('sensor-device-001'));
const devicePublicKey = '0x...';
const metadata = 'ipfs://device-metadata-hash';

const registerTx = await registry.registerDevice(deviceId, devicePublicKey, metadata);
await registerTx.wait();
console.log('IoT device registered on IoTeX blockchain!');

// Device publishes verified sensor data
const sensorData = ethers.AbiCoder.defaultAbiCoder().encode(
  ['uint256', 'uint256', 'uint256'],
  [temperature, humidity, timestamp]
);
const dataSignature = await deviceWallet.signMessage(ethers.getBytes(sensorData));

const publishTx = await registry.publishData(deviceId, sensorData, dataSignature);
await publishTx.wait();
console.log('Verified sensor data published on-chain!');

from web3 import Web3

w3 = Web3(Web3.HTTPProvider('https://rpc.crypto-chief.com/iotex/YOUR_API_KEY'))

print('Connected to IoTeX:', w3.is_connected())
print('Chain ID:', w3.eth.chain_id)  # 4689
print('Latest block:', w3.eth.block_number)

# DePIN rewards contract
DEPIN_REWARDS_ADDRESS = '0x...'
depin_rewards_abi = [
    {
        'name': 'submitProofOfWork',
        'type': 'function',
        'inputs': [
            {'name': 'deviceId', 'type': 'bytes32'},
            {'name': 'workProof', 'type': 'bytes'},
            {'name': 'dataHash', 'type': 'bytes32'}
        ],
        'outputs': []
    },
    {
        'name': 'claimRewards',
        'type': 'function',
        'inputs': [{'name': 'deviceId', 'type': 'bytes32'}],
        'outputs': [{'name': 'amount', 'type': 'uint256'}]
    }
]

depin_rewards = w3.eth.contract(
    address=DEPIN_REWARDS_ADDRESS,
    abi=depin_rewards_abi
)

# Device submits proof of infrastructure contribution
device_id = w3.keccak(text='wireless-node-042')
work_proof = b'...merkle-proof-data...'
data_hash = w3.keccak(text='connectivity-data-batch')

tx_hash = depin_rewards.functions.submitProofOfWork(
    device_id,
    work_proof,
    data_hash
).transact({'from': device_operator_address})

receipt = w3.eth.wait_for_transaction_receipt(tx_hash)
print('DePIN contribution proof submitted!')

# Claim IOTX rewards for infrastructure service
claim_tx = depin_rewards.functions.claimRewards(device_id).transact(
    {'from': device_operator_address}
)
w3.eth.wait_for_transaction_receipt(claim_tx)
print('Earned IOTX for providing decentralized infrastructure!')

const { ethers } = require('ethers');
const provider = new ethers.WebSocketProvider('wss://rpc.crypto-chief.com/iotex/ws/YOUR_API_KEY');

// Monitor device registrations
const DEVICE_REGISTRY = '0x...';
const registrationFilter = {
  address: DEVICE_REGISTRY,
  topics: [ethers.id('DeviceRegistered(bytes32,address,uint256)')]
};

provider.on(registrationFilter, (log) => {
  const decoded = ethers.AbiCoder.defaultAbiCoder().decode(
    ['bytes32', 'address', 'uint256'],
    log.data
  );
  console.log('New IoT device registered:');
  console.log('Device ID:', decoded[0]);
  console.log('Owner:', decoded[1]);
  console.log('Timestamp:', new Date(Number(decoded[2]) * 1000).toISOString());
});

// Monitor sensor data publications
const dataPublicationFilter = {
  address: DEVICE_REGISTRY,
  topics: [ethers.id('DataPublished(bytes32,bytes32,uint256)')]
};

provider.on(dataPublicationFilter, (log) => {
  const decoded = ethers.AbiCoder.defaultAbiCoder().decode(
    ['bytes32', 'bytes32', 'uint256'],
    log.data
  );
  console.log('Verified sensor data published:');
  console.log('Device ID:', decoded[0]);
  console.log('Data Hash:', decoded[1]);
});

console.log('Monitoring IoTeX for IoT and DePIN activity...');