Accural

The agent-native settlement and coordination layer — Solana, Ethereum, Stripe, UPI, and card networks behind one policy engine.

Accural lets autonomous AI agents move real money across on-chain rails (SPL tokens, ERC-20) and fiat rails (Stripe cards, Razorpay UPI) without either (a) a human signing every action or (b) an agent holding unsupervised custody. Every spend — on-chain or fiat — is gated by the same policy engine: per-transaction caps, rolling budget windows, approval thresholds with owner co-signature, recipient blocklists, and immutable reconciliation records.

---

The problem Accural solves

Agent-payment designs fail in one of two ways:

1. The human signs everything. The agent has no autonomy; "policies" are theater because every transaction was already human-approved by definition.
2. The agent (or its backend) holds the keys. A prompt injection or compromised planner becomes a wallet drainer.

Accural's answer is a delegated authority + treasury architecture enforced on-chain (Solana program / EVM contract) and mirrored at the control plane for fiat:

• Owners register an agent, set a policy, and fund a program-owned treasury.
• Owners grant delegated authorities (agent keypairs) with optional expiry.
• Delegates settle payments autonomously within hard limits. Above-threshold spends require the owner as an actual co-signer (on-chain) or a single-use owner approval (EVM).
• Task escrows require matching payment intents and release only by the designated verifier. Expired escrows refund permissionlessly. Fiat escrows map to manual-capture authorizations (Stripe) or Accural-state-gated UPI collect flows (Razorpay).

Rails

Rail	Family	Escrow model	Currencies	Enforcement
solana	chain (Anchor)	PDA vault + verifier release	USDC	fully on-chain
ethereum	chain (Solidity)	contract-held + verifier release	ERC-20 stables	fully on-chain (AccuralCore.sol)
stripe_card	processor	manual-capture authorization hold	USD/EUR/GBP/…	control plane + provider state
razorpay_upi	processor	Accural-gated UPI collect	INR	control plane + provider state
card	network	via processors only	follows processor	brand routing (Visa/Mastercard/Amex/Discover/RuPay IINs); PANs never touch Accural

Cards (Visa/Mastercard) are networks, not APIs. Merchants accept them through processors; Accural integrates the processors (Stripe today, Razorpay for India), detects brands from IIN ranges for routing/reconciliation labels, and structurally refuses raw card data (PCI scope stays with the processor — SAQ-A style).

Architecture

graph TD
    A[AI Agent delegate key] --> B{Rail?}
    B -->|solana| C1[Accural Anchor program]
    B -->|ethereum| C2[AccualCore.sol]
    B -->|stripe_card| D1[Stripe REST - manual capture]
    B -->|razorpay_upi| D2[Razorpay REST - orders/capture]
    C1 & C2 & D1 & D2 --> E[Reconciliation ledger]
    O[Owner] -->|policies, delegates, treasury| C1
    O -->|same controls| C2
    W[Webhooks: stripe / razorpay] -->|HMAC verified| E

Loading

Trust boundaries

Actor	Can do	Cannot do
Delegate agent	Spend from treasury within policy; create intents; cancel unfunded intents	Exceed caps; pass approval threshold alone; act after expiry; touch owner wallets
Verifier	Release funded escrows to the beneficiary	Release self-dealt escrows (verifier ≠ owner ≠ beneficiary)
Anyone	Trigger deadline refunds after expiry	Redirect refunds (destination pinned to original funding source)
Owner	Policies, delegates, sweeps, refunds, direct funding	Move funds without an on-chain/control-plane audit trail

Getting started

git clone https://github.com/dwan-ith/Accural.git
cd Accural/client
npm install

# Repo root: compiles the program + runs all test suites (Rust unit tests,
# protocol semantics, backend API, instruction encoding, rail adapters, EVM ABI).
powershell -ExecutionPolicy Bypass -File .\scripts\verify-mvp.ps1

Configure via .env (see .env.example). Fiat rails run in ACCURAL_FIAT_MODE=dry_run without credentials using a deterministic offline processor — the full control-plane flow is exercisable with zero risk before going live.

Multi-rail walkthrough (local mode)

cd client
$env:ACCURAL_SETTLEMENT_MODE="local"; $env:ACCURAL_FIAT_MODE="dry_run"
npm run backend:start

# 1. Create agent + policy allowing both fiat rails
curl -X POST localhost:8787/agents    -d "{\"agentId\":\"jarvis\"}"
curl -X POST localhost:8787/policies  -d "{\"agentId\":\"jarvis\",\"maxPerTransaction\":\"50\",\"sessionBudget\":\"100\",\"approvalRequiredAbove\":\"40\",\"allowedRails\":[\"razorpay_upi\"]}"

# 2. UPI escrow in one call: creates the Razorpay order AND the local escrow
curl -X POST localhost:8787/rails/razorpay/upi-escrow-plan -d "{...}"
# 3. Payer approves in their UPI app (Checkout) out-of-band
# 4. Settlement arrives via signature-verified webhook -> escrow RELEASED

Chain flows keep the plan-then-execute model: planning routes return wallet-ready instructions; execution is separate, authenticated, allowlisted, and simulated by default.

Backend surface

• GET /rails — capability matrix per rail + configuration status
• POST /rails/stripe/escrow-plan | release | refund
• POST /rails/razorpay/upi-escrow-plan | release | refund
• POST /webhooks/stripe, POST /webhooks/razorpay — HMAC-verified over raw bodies; replay-tolerant (Stripe) and constant-time compared
• Full Solana planning suite (/solana/*-plan), authenticated bundle execution, local-mode ledger routes

Security notes

• Loopback bind by default; bearer token required for mutating routes when configured; webhooks are exempt from bearer auth because they authenticate via provider HMAC signatures instead.
• Bundle execution: program allowlist, simulation-first, fail-closed without credentials.
• PCI guard: request bodies containing number/pan/cvv fields are rejected outright.
• See SECURITY.md for the threat model and honest limitations (FX handling, Sybil bounds on reputation, UPI's lack of merchant-side holds, and more).

License

MIT. See LICENSE.