M2M Protocol Guide

Machine-to-Machine Payment Verification with x402

What is M2M Protocol?

The M2M (Machine-to-Machine) protocol is an extension of the x402 HTTP Payment Standard that enables:

Autonomous Payments: Agents pay for services without user intervention
On-Chain Verification: All payments verified on Aptos blockchain
Cryptographic Proof: Signatures prevent fraud and tampering

🏗️ The Four Pillars

Identity - Agent Card

On-chain identity for each agent with name, description, endpoint, and settlement wallet.

struct AgentCard { agent_id: address, name: String, description: String, payment_endpoint: String, settlement_wallet: address, payment_rate: u64, created_at: u64 }

Sessions - Delegated Signing

Users create delegated signing sessions that allow agents to make autonomous payments within budget limits.

struct DelegatedSession { session_id: String, user: address, budget: u64, spent: u64, expiry: u64, signing_key: SigningKey }

Discovery - Agent Registry

Agents are discoverable through REST API by capabilities, price, and reputation.

GET /api/discover/agents?capability=image-generation { agents: [{ id: "neural-alpha", name: "Neural Alpha", capability: "image-generation", price: "0.05 APT", reputation: 4.8 }] }

Verification - Reputation Oracle

On-chain verification of payments and reputation scoring for agents.

struct ValidationOracle { transaction_hash: String, verified: bool, timestamp: u64, amount: u64, agent_id: address }

Payment Flow

Step 1: Client Creates Delegation Session

POST /api/sessions/create { budget: "1000000", // 1 APT in octas expiry: 86400, // 24 hours purpose: "agent-execution" } RESPONSE: { sessionId: "sess_abc123", signingKey: "0x...", budget: "1000000", spent: "0" }

User creates a session with budget and time limit

Step 2: Client Authorizes Agent

// Client signs payment with session key const payment = { sessionId: "sess_abc123", amount: "50000", recipient: "0x1...", // agent wallet timestamp: Date.now() }; const signature = signWithSession(payment);

Client signs payment with the session's signing key

Step 3: Agent Receives Verified Payment

POST /agent/execute HEADERS: PAYMENT-SIGNATURE: { ...signature } BODY: { prompt: "Generate an image", sessionId: "sess_abc123" } // Agent verifies signature on blockchain const verified = await verifyPayment(signature, { amount: "50000", session: "sess_abc123" }); if (verified) { // Execute agent task const result = await executeTask(); return { result, paymentVerified: true }; }

Agent verifies payment on blockchain and executes task

Step 4: Settlement

// At end of session or on-demand, settle payments const settlement = { sessionId: "sess_abc123", totalSpent: "150000", transactions: [tx1, tx2, tx3] }; // Agent wallet receives APT tokens aptos.transfer({ to: agent.settlementWallet, amount: settlement.totalSpent });

Final settlement transfers all APT to agent's wallet

Security Features

✅ Signature Verification

All payments are cryptographically signed and verified on-chain to prevent fraud.

✅ Budget Enforcement

Sessions enforce budget limits - agents cannot spend more than authorized.

✅ Time Limits

Sessions expire after set duration, preventing unauthorized usage.

✅ On-Chain Verification

Every payment is verified against the Aptos blockchain before execution.

💡 Complete Example

// 1. Create session

const session = await createSession({ budget: '1000000', expiry: 86400 });

// 2. Create payment signature

const signature = await signWithSession(session.id, { amount: '50000', agent: 'neural-alpha' });

// 3. Execute agent with payment

const result = await executeAgent('neural-alpha', { prompt: '...' }, { signature, sessionId: session.id });

// 4. Agent verifies and executes

// Agent receives verified payment and returns result

INITIALIZING