Skip to main content
AroPay orchestrates confidential payments on public ledgers: sealed, private transfers whose amounts never appear in cleartext on-chain. It runs on the Aro Confidential Rails, built on Zama Protocol FHE. AroPay pairs a web dashboard with a versioned JSON API at /api/v1. Both surfaces drive the same backend, and every on-chain action executes for real on the environment’s ledger: Ethereum Mainnet (chain ID 1) in production, Sepolia (chain ID 11155111) on the sandbox.
AroPay user flow: provisioning, sign-in, wallet setup, funding, money movement, and tracking

The full AroPay journey: from provisioning to programmatic money movement.

​
The building blocks

​
Two rails, one API

Money in AroPay lives on two rails that stay 1:1 with each other:

Public rail

The stablecoin, a standard ERC-20 (a test stable on the sandbox). Balances and transfer amounts are visible to anyone on a block explorer.

Confidential rail

cAROUSD, an ERC-7984 confidential token. Amounts are encrypted with fully homomorphic encryption (FHE), so the chain records that value moved, never how much.
You move between rails with mint (stable → cAROUSD) and redeem (cAROUSD → stable). Within the confidential rail, private transfers keep amounts encrypted end-to-end. See Confidential transfers for how the encryption works. The money behind the rails is environment-specific: in production (Mainnet), cAROUSD is backed 1:1 by liquid stablecoin held at the Aro Liquidity Commitment and wallets are funded by real deposits; on the Sepolia sandbox, a test stablecoin stands in and a faucet provides funds. The rail mechanics are identical in both.

​
The dashboard is an API client

Every dashboard feature (funding, minting, transfers, receipts, settings) calls the same /api/v1 endpoints you integrate against. That has two practical consequences:
  1. Parity is guaranteed. If the UI can do it, your integration can do it with the same request shapes.
  2. You can mix surfaces freely. Kick off a mint from a script, watch it confirm in the dashboard, download the receipt from either.

​
The operator

The operator is a platform-owned wallet that does the work your integration shouldn’t have to:
  • pays out faucet requests on the sandbox (test stablecoin + a gas top-up),
  • mints cAROUSD in float mode,
  • settles redemptions by paying stablecoin back to your wallet.
The operator signs inside AroPay’s background worker, the same process that executes every money-movement request after the API has accepted it (see Transactions). If the operator runs low on stablecoin, faucet transactions end up FAILED with errorCode: "faucet_failed"; if it runs low on gas or payout liquidity, redemptions wait in SETTLING until it is topped up rather than failing. See Troubleshooting.

​
Mint modes: backed vs. float

Deployments run in one of two mint modes. The API is identical in both; only the on-chain mechanics differ.
Which mode your deployment uses is an operational setting. In backed mode a mint requires the custodial wallet to actually hold stablecoin; in float mode the operator mints directly. Either way you call POST /mint.

​
Server-side FHE

Confidential operations (encrypting mint amounts, decrypting custodial balances, publicly decrypting redeem burns) run server-side through the Zama Protocol relayer against the Zama deployment for the environment’s chain (Mainnet in production, Sepolia on the sandbox). Two things follow:
  • You never handle FHE keys or ciphertexts. The API takes and returns plain decimal strings.
  • The first confidential call after a deployment restart can be slower while FHE keys are fetched. Subsequent calls are faster.

​
Host isolation

AroPay runs on its own hosts: aropay.aro.media in production and dev.aropay.aro.media for the sandbox. AroPay routes only resolve there, and admin routes 404 on AroPay hosts; the two surfaces are isolated at the proxy layer.