Rohan Protocol (v0.8.1)

The Sovereign Privacy & Settlement Layer for Autonomous AI Agents on the Midnight Blockchain.

Rohan Protocol equips autonomous AI agents with zero-knowledge intent commitments, confidential state transitions, and a complete, verifiable audit lifecycle. Sensitive parameters (budgets, vendor contracts, PII) are strictly canonicalized (RFC 8785) and hashed in client RAM—never exposed on-chain or leaked in LLM context windows.

🔄 The Closed-Loop Multi-Agent Architecture

Rohan Protocol eliminates the classic "dead-end" MCP agent problem by establishing a complete, multi-turn lifecycle between coordinating agents:

┌───────────────────┐   ┌───────────────────┐   ┌───────────────────┐   ┌───────────────────┐
│    Agent Alpha    │   │    Agent Beta     │   │    Agent Beta     │   │    Agent Beta     │
│ (State Mutation)  │   │ (State Inspection)│   │ (History Review)  │   │ (Agreement Audit) │
└─────────┬─────────┘   └─────────┬─────────┘   └─────────┬─────────┘   └─────────┬─────────┘
          │                       │                       │                       │
          │ 1. rohan_execute_handshake│ 2. rohan_get_ledger_state│ 3. rohan_get_transaction_history│ 4. rohan_verify_commitment
          │    (Confidential Payload)│    (Read Anchored Root) │    (Settlement Receipts) │    (RFC 8785 In-Memory JCS)
          ▼                       ▼                       ▼                       ▼
┌────────────────────────────────────────────────────────────────────────────────────────┐
│                                 Rohan Protocol Relayer                                 │
│                     Midnight Preprod L1 Settlement & Paymaster                         │
└────────────────────────────────────────────────────────────────────────────────────────┘

Step 1 — Write (rohan_execute_handshake): Agent Alpha commits an intent. The Relayer verifies proof commitments and anchors the state root on Midnight Preprod L1. The legacy rohan_zk_handshake name remains accepted.
Step 2 — Read (rohan_get_ledger_state): Agent Beta inspects the contract's anchored state root, block height, and transaction receipt from cache (0 Gas, <1 ms).
Step 3 — History (rohan_get_transaction_history): Agent Beta lists recorded settlement transactions and receipts (0 Gas).
Step 4 — Verify (rohan_verify_commitment): Agent Beta checks plaintext against its canonical SHA-256 payload digest in local RAM (0 Gas). This is the inner payload digest, not the outer on-chain intentHash.

🛠️ The 4 MCP Lifecycle Tools

Tool	Category	Gas Cost	Latency	Description
`rohan_execute_handshake`	Mutation / Write	Subsidized (Paymaster)	~30s (L1 Block)	Executes a confidential state transition anchored on Midnight Preprod. The legacy `rohan_zk_handshake` alias is accepted.
`rohan_get_ledger_state`	Inspection / Read	0 Gas	<1 ms (RAM Cache)	Reads current anchored state root, block height, and tx receipt from the 15s write-through cache.
`rohan_get_transaction_history`	Inspection / Read	0 Gas	<1 ms (SQLite)	Lists recent recorded settlement transactions and receipts.
`rohan_verify_commitment`	Audit / Verify	0 Gas	<1 ms (Local RAM)	Checks plaintext against its payload digest via RFC 8785 JCS + SHA-256; supply the inner payload digest, not the outer on-chain `intentHash`.

📦 Monorepo Packages

@rohan-protocol/sdk: Enterprise Node.js SDK (Node 22 CI-tested) with cryptographic zeroization, RFC 8785 canonicalization, and state inspection. Browser support is not included; isomorphic support is separate R&D for RFC-006 / Midnight Grants Milestone 1.
@rohan-protocol/mcp: Official Model Context Protocol (MCP) server for Claude Desktop, Cursor, Cline, and Gemini, with local Ed25519 agent identity and optional agentId inference from its signer.
@rohan-protocol/webmcp: Browser-native WebMCP shield with zero-width character sanitization (V-07).

🚀 Quickstart

1. Install SDK

npm install @rohan-protocol/sdk

2. Basic SDK Usage

import { RohanClient, canonicalizeJson } from '@rohan-protocol/sdk';

const client = new RohanClient({
  contractAddress: '585ac0c4448257507d8ffa2a89e2aa00abd86ec9e94bdb6f553bc83e05f4dd0e',
});

// 1. Inspect on-chain state (Read)
const state = await client.getLedgerState();
console.log('Current Root:', state.currentStateRoot, 'Block:', state.blockHeight);

// 2. Submit a confidential handshake (Write)
const receipt = await client.submitHandshake({
  agentId: 'did:midnight:agent-alpha',
  intent: 'Vendor Purchase Order #1042',
  privateData: { budgetUsd: 75000, approvalCode: 'AUTH-99' },
});
console.log('Confirmed TxHash:', receipt.txHash);

// 3. Verify plaintext commitment locally (Verify)
const audit = await client.verifyCommitment(
  { budgetUsd: 75000, approvalCode: 'AUTH-99' },
  receipt.intentHash
);
console.log('Cryptographic match?', audit.valid);

🛡️ Security & Zero-Trust Principles

RFC 8785 JSON Canonicalization Scheme (JCS): Deterministic, cross-platform key sorting and whitespace elimination.
DoS & ReDoS Guarding: Recursive depth ceiling (max. 32 levels) and RAM payload bounds (max. 256 KB).
Zeroize RAM Sanitation: Sensitive witnesses and private keys are scrubbed from RAM immediately after commitment derivation.
Optimistic Credit Escrow: Atomic balance reservations prevent concurrent quota-drain exploits.

mcp

Documentation