Autonomous Vehicle Payment System

What it does:
Automates payments for autonomous vehicles (rides, tolls, charging) based on usage, distance, or service agreements using smart contracts.

Why it matters:
Eliminates intermediaries, ensures timely and transparent payments, reduces disputes, and enables programmable mobility services.

How it works:

Vehicles or mobility services register with metadata, pricing, and service terms
Users initiate payments per ride, per km, or per service usage
Smart contract automatically releases payments to vehicle owners, charging stations, or service providers
Supports subscription-based rides, tolls, or charging plans
Integrates with AI Agent Payment Contract, Tokenized Wallets, or Play-to-Earn Reward Engine for mobility incentives
Dashboards display trip history, usage costs, and payment confirmations

      // SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/access/Ownable.sol";

/**
 * @title AutonomousVehiclePayment
 * @author Nam
 * @notice Automates payments for autonomous vehicle services on-chain
 */
contract AutonomousVehiclePayment is Ownable {

    struct Vehicle {
        string name;
        address payable owner;
        uint256 pricePerKm; // in wei
        bool active;
    }

    mapping(uint256 =&gt; Vehicle) public vehicles;
    uint256 public vehicleCount;

    // -------------------- EVENTS --------------------

    event VehicleRegistered(uint256 indexed vehicleId, string name, address owner, uint256 pricePerKm);
    event VehicleDeactivated(uint256 indexed vehicleId);
    event PaymentMade(uint256 indexed vehicleId, address user, uint256 distance, uint256 amount);

    // -------------------- VEHICLE MANAGEMENT --------------------

    function registerVehicle(string calldata _name, uint256 _pricePerKm) external {
        require(_pricePerKm &gt; 0, "Price must be &gt;0");

        vehicleCount += 1;
        vehicles[vehicleCount] = Vehicle({
            name: _name,
            owner: payable(msg.sender),
            pricePerKm: _pricePerKm,
            active: true
        });

        emit VehicleRegistered(vehicleCount, _name, msg.sender, _pricePerKm);
    }

    function deactivateVehicle(uint256 _vehicleId) external {
        Vehicle storage v = vehicles[_vehicleId];
        require(msg.sender == v.owner, "Not vehicle owner");
        v.active = false;

        emit VehicleDeactivated(_vehicleId);
    }

    // -------------------- PAYMENT MANAGEMENT --------------------

    function payForRide(uint256 _vehicleId, uint256 _distanceInKm) external payable {
        Vehicle storage v = vehicles[_vehicleId];
        require(v.active, "Vehicle inactive");

        uint256 totalAmount = v.pricePerKm * _distanceInKm;
        require(msg.value == totalAmount, "Incorrect payment");

        v.owner.transfer(msg.value);

        emit PaymentMade(_vehicleId, msg.sender, _distanceInKm, msg.value);
    }

    // -------------------- VIEW FUNCTIONS --------------------

    function isVehicleActive(uint256 _vehicleId) external view returns (bool) {
        return vehicles[_vehicleId].active;
    }

    function getVehiclePrice(uint256 _vehicleId) external view returns (uint256) {
        return vehicles[_vehicleId].pricePerKm;
    }
}