A
CallGuard
on-chain SLA marketplace · arc testnet
Disconnected

Pay-per-call, enforced on-chain.

Service providers stake USDC and commit to an SLA. Callers — including AI agents — pay per request and receive a cryptographically signed receipt. If the provider misses the deadline, the stake is slashed automatically. No arbiter, no middleman.

—
Registered providers
—
Calls on chain
—
Slashes enforced

How it works

Three scenarios that cover the full lifecycle. Read them before you touch a button — the rest of the app will make instant sense.

✓ Happy path

Provider honors the SLA

The common case. Provider responds in time, gets paid, reputation goes up.

1. Caller opens a call and escrows 1 USDC in the contract.
2. Provider delivers the response off-chain within the SLA window.
3. Provider signs a receipt and calls submitReceipt().
→ Escrow released to provider. +1 USDC earned. Reputation +1.
✕ Timeout

Provider misses the deadline

What keeps the marketplace honest. No response in time? The caller gets paid back, and the provider loses stake.

1. Caller opens a call, escrows 1 USDC, waits.
2. Provider does not deliver within the SLA window the provider committed to.
3. Anyone calls claimTimeout() after the deadline.
→ Caller gets 1 USDC refund + 20% of provider's stake. Provider loses slash + reputation.
★ Reputation

Track record, on-chain

Every honored call and every slash is counted in the contract. Anyone — including other contracts — can read a provider's score.

· Fresh provider: 66 (neither trusted nor distrusted)
· After 1 honored call: 75
· After 10 honored calls: 92
· One slash from zero history: 50
→ Formula: (good + 2) / (total + 3) × 100 — Bayesian, readable on-chain.
⚡ v4

Composable payment rails

v4 adds five ways to pay, a verifiable identity layer, and ERC-8183 job settlement — all settling into the same SLA enforcement.

· x402 — agents pay via the HTTP 402 protocol; callService() fires on payment.
· CCTP — pay from Ethereum, Base or Polygon; Circle bridges USDC, Arc enforces the SLA.
· ERC-8004 NFT — providers bind an on-chain AgentIdentity NFT to their registration.
· Circle Gateway Nanopayments — gasless 0.001 USDC micro-payments; no wallet prompt, no gas, no tx confirmation.
· ERC-8183 Jobs — trustless job settlement; client locks USDC, provider delivers, evaluator approves, contract pays.
→ Every path ends the same way: staked USDC, signed receipt, automatic slash on timeout.
What is CallGuard?

CallGuard is an on-chain marketplace where service providers stake USDC to commit to SLAs, and callers pay per request. If a provider fails to respond in time, their stake is automatically slashed — no arbitrator or intermediary required.

1
Get testnet USDCfaucet.circle.com → select Arc Testnet → paste your wallet address. On Arc, USDC is both the gas token and currency — one token is all you need.
2
Connect your walletClick the "Connect wallet" button. MetaMask will add Arc Testnet automatically. You can also pay from Ethereum, Base, or Polygon via CCTP — see the chain selector when calling a service.
3
Choose your roleFollow the Caller or Provider flow step by step using the tabs above.
💡 Tip: You can use the same wallet as both caller and provider. For separate testing, two different MetaMask accounts are recommended.
Caller Flow

You pay USDC to call a service. If the provider responds in time, the call completes. If not, your payment is refunded and the provider is penalized.

1
Select a providerOpen the Call a service section in the left panel. Enter a Provider ID (e.g. 1). Price and SLA duration are shown automatically.
2
Send a requestType any text in the request payload field (e.g. ping). Click Approve & call — MetaMask will ask you to sign two transactions: USDC approval + call opening.
3
Track the countdownThe call appears in your Your Calls panel and a countdown begins. If the provider responds, it becomes "completed".
4
Timeout → Claim slashOnce the SLA period expires, the claim slash button appears. Click it → MetaMask opens → confirm. Your payment is refunded plus a bonus from the provider's stake.
⏱ Note: Alerts fire automatically when the countdown turns yellow (30s left) and red (10s left). If you are a provider, submit your receipt immediately!
Provider Flow

You become a service provider by staking collateral. Each successful response increases your reputation. Miss the SLA window and a portion of your stake is slashed.

1
Register & stakeOpen the Register as provider section. Set a minimum 10 USDC stake, price, response time, and slash %. Leave the signer address blank to use your own wallet.
2
Respond when calledWhen a CallStarted event arrives, the SLA clock starts. Open the Submit receipt section — the Call ID is pre-filled, just enter your response payload.
3
Sign & submit the receiptClick Sign & submit. MetaMask will first ask for an EIP-712 typed-data signature (readable Receipt fields), then an on-chain transaction.
4
Collect payment & earn reputationOnce the receipt is accepted, the escrowed USDC is transferred to you. Each successful response increases your on-chain reputation score.
🚨 Critical: You must be connected with the signer address to submit a receipt. If your provider panel shows "✓ matches your wallet", you are ready.
Minimum stake10 USDC
Minimum response time10 seconds
Slash range0% – 100%
Reputation formula(successful + 2) / (total + 3) × 100
Slash System

The slash system is the economic enforcement mechanism that holds providers accountable to their SLA commitments. No arbitrator or trusted party required.

⚡
When does a slash occur?If the provider does not call submitReceipt() within maxResponseTime, the deadline expires. The caller can trigger a slash via claimTimeout().
💰
Calculationslash = stake × slashBps / 10000
E.g. 10 USDC stake + 20% slash → 2 USDC is deducted and sent to the caller.
🔄
Fund flowThe escrowed call fee is refunded to the caller. The slashed stake is also sent to the caller. The remaining stake stays with the provider.
📉
Reputation impactEach slash lowers the provider's on-chain reputation counter, making them less likely to be chosen.
Example: 10 USDC stake · 20% slash · 120s SLA. Caller pays 1 USDC. Provider does not respond within 120s. Caller clicks claim slash → 1 USDC refunded + 2 USDC bonus. Provider stake drops to 8 USDC.
Frequently Asked Questions
How does receipt signing work?
Receipts use EIP-712 typed-data signing. When you sign, MetaMask shows the structured Receipt fields (callId, responseHash) in a readable format — not raw hex.
What is the Call ID and where does it come from?
It is the unique 32-byte identifier generated on-chain when callService() is invoked. It is auto-filled after you click Approve & call.
Can I submit a receipt after the SLA deadline?
No. The contract rejects submitReceipt() once the deadline has passed. Keep an eye on the countdown timer!
Can I be both a provider and a caller with the same wallet?
Technically yes, but two separate accounts are recommended for testing.
Can I withdraw my stake?
You can unstake when there are no pending calls. A cooldown period applies.
How is the reputation score calculated?
Bayesian formula: (successful + 2) / (total + 3) × 100. A new provider starts at 66. Each successful call increases the score; each slash decreases it.

Live activity

streaming from arc testnet
loading recent activity…
ServiceRegistry
PayPerCall
USDC
CrossChainReceiver 0x28a683A5fAB9B5DC2608089e86d733aB1f116e5c
RegisterWithNFT 0x0aBC433356754Cd269bEF9A46273d7a152a0F169
AgenticCommerce 0x0747EEf0706327138c69792bF28Cd525089e4583
LIVE --:--:-- · Arc Testnet
—
honor rate
Providers
—
registered
Calls
—
all-time
Receipts
—
SLA honored
Slashed
—
USDC redirected

Actions

Register as provider
The address that will sign receipts. For testing, leave blank — your own address is used.
Recommended: 60s or more. MetaMask signing takes ~10s — tight SLAs cause receipt failures.
Just testing the demo? Leave this blank or put any URL. In production, this is where callers would send API requests after paying.
📊 Live calculator
Stake locked 10.00 USDC
Loss per SLA violation 2.00 USDC (20%)
Max slashes before stake drained 5 slashes
Revenue per 10 successful calls 10.00 USDC
Break-even after N calls 10 calls
Advanced
The NFT version mints an ERC-8004 AgentIdentity and registers in one flow. The basic version skips the NFT.
Call a service ⚡ Gas-free
No gas required. You sign an EIP-3009 authorization off-chain — no USDC approval tx, no gas fee. The facilitator pays gas on your behalf and settles the payment on Arc in a single transaction.
Paying from Arc Testnet directly. No bridging required.
Enter a provider id to fetch SLA terms.
Submit receipt (provider)
Response is hashed and signed with EIP-712 typed data. On-chain stores only the hash.
EIP-712 signing: when MetaMask opens the signature prompt, you'll see structured Receipt fields (callId, responseHash) — readable typed data, not raw hex.
Claim timeout (caller)
Only works after the SLA deadline has passed. Refunds your payment and slashes the provider's stake.
⚡ Auto-router — pick best provider

Automatically selects the provider with the highest reputation score that is currently active. You can set a max price filter.

🔀 Multi-provider call

Send the same request to multiple providers simultaneously. The first one to submit a valid receipt gets paid; the others are ignored (calls time out naturally).

Your provider

🏗️
You're not a provider yet.
Stake USDC to start earning from service calls.

📈 Analytics

Goldsky subgraph · live data
TOTAL CALLS
—
HONOR RATE
—
ACTIVE PROVIDERS
—
AVG PRICE
—
Top Providers by Activity
Recent Call Status

📈 Analytics

Goldsky subgraph · live data
TOTAL CALLS
—
HONOR RATE
—
ACTIVE PROVIDERS
—
AVG PRICE
—
Top Providers by Activity
Recent Call Status

🔒 Arc Privacy Sector

APS · opt-in private SLA calls
Coming soon — Arc Privacy Sector is in development.
APS runs a second execution environment alongside Arc's public chain. Private transactions are encrypted with the APS network key and executed inside hardware enclaves — validators can't read the payload, and no event logs are exposed to the public ledger.
🔐 Private SLA calls
Call a provider without revealing your wallet address. The provider receives the request and USDC but cannot see who called — enforced by the enclave, not by trust.
🕵️ Confidential payloads
Request hashes and response data stay encrypted on-chain. Only the caller and provider can decrypt the content — slashing still works on the encrypted proof.
⚡ Same SLA enforcement
Private calls use the same staking and slashing rules as public calls. The SLA is enforced by the contract — privacy doesn't weaken the guarantee.
🔒
APS private transactions require X-Wing KEM encryption and Arc enclave RPC nodes.
CallGuard will integrate APS private calls when the precompile API is public.

Session Budget

spending cap

My Activity

connect wallet to see your on-chain activity

Your calls

no calls yet — make one or submit a receipt

All providers

click a row for details
loading providers…

⚡ Nanopayment

Circle Gateway · 0.001 USDC · gasless

Gasless micro-payments via Circle Gateway. No MetaMask, no gas, no tx confirmation — facilitator handles everything server-side.

CALLS MADE
0
PENDING BATCH
—
SETTLED BALANCE
—
How it works: 1. You click → 2. Facilitator signs EIP-3009 off-chain → 3. Circle Gateway verifies instantly → 4. Batch settles on-chain later. No wallet prompt. No gas. Payments batch into a single on-chain tx.
Result will appear here.

🤖 MCP Agent

Model Context Protocol · AI agent integration

CallGuard ships a built-in MCP server. Any MCP-compatible AI agent — Claude Desktop, Cursor, or any other client — can discover providers, check health, and send payments without writing any integration code.

Available tools
list_providers — query active providers from Goldsky subgraph
get_leaderboard — top providers by on-chain reputation
get_provider_health — live endpoint ping for any provider
nanopay — send 0.001 USDC via Circle Gateway, gasless
get_network_stats — total providers, calls, network overview
arc_docs_search — search Arc Network official documentation
1 · Clone the repo
git clone https://github.com/muazzezwq/callguard.git
cd callguard/x402-facilitator
npm install
2 · Add to Claude Desktop config
{
  "mcpServers": {
    "callguard": {
      "command": "node",
      "args": ["/path/to/callguard/x402-facilitator/mcp-server.js"]
    }
  }
}
3 · Test the server
echo '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}' | node mcp-server.js
4 · Or use remote MCP (no clone needed)
{
  "mcpServers": {
    "callguard": {
      "type": "sse",
      "url": "https://arcsla-eu.onrender.com/sse"
    }
  }
}
📁 Where is the config file? detecting...

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json
Linux: ~/.config/Claude/claude_desktop_config.json

Create the file if it doesn't exist. Restart Claude Desktop after saving.
Example agent prompts:
· "List the top 5 CallGuard providers by reputation"
· "Check if provider #3 is online"
· "Send a nanopayment via CallGuard"
· "What are the current CallGuard network stats?"

⚙️ ERC-8183 Jobs

Arc standard — trustless job settlement

A job moves through five steps, each performed by a specific role. Open a step when it's your turn — you don't need to fill in all of them at once.

Who enters what?
· Create job — Client enters the provider wallet address and a description. The client is you (your connected wallet).
· Set budget — Provider sets the price in USDC. Solo testing? Use your own address as provider and do this step too.
· Fund — Client locks USDC into escrow. Your wallet needs USDC on Arc Testnet.
· Submit — Provider submits proof of completed work (any text).
· Complete — Evaluator approves and USDC releases automatically. Default evaluator is the client.
💡 Solo test: enter your own wallet as provider and evaluator — you can do all 5 steps yourself.
1
Create
2
Set Budget
3
Fund
4
Submit
5
Complete
1 Create a job Client ›

Open a job with the provider you want to work with. No funds move yet.

2 Set the budget Provider ›

The provider names their price for the work. This is filled in automatically after you create a job above.

3 Fund the escrow Client ›

Once a budget is set, the client locks that amount of USDC into the job's escrow.

4 Submit the deliverable Provider ›

The provider submits proof of completed work. This gets hashed and recorded on-chain.

5 Approve & settle Evaluator ›

The evaluator approves the work. USDC releases from escrow to the provider automatically.

Job results will appear here.

SDK — Quick Integration

5-line setup

Integrate CallGuard into any JavaScript app or AI agent. Copy the snippet below and replace the provider ID and payload.

// npm install ethers (ethers v6) import { ethers } from "ethers"; const provider = new ethers.BrowserProvider(window.ethereum); const wallet = await provider.getSigner(); const usdc = new ethers.Contract("0x3600000000000000000000000000000000000000", ["function approve(address,uint256) returns(bool)"], wallet); const arc = new ethers.Contract("0x10387347678d9f7106D5625bE0BD6C915158B130", ["function callService(uint256,bytes32) returns(bytes32)"], wallet); // 1. Approve USDC await usdc.approve(arc.target, ethers.parseUnits("1", 6)); // 2. Open call to provider #1 const requestHash = ethers.keccak256(ethers.toUtf8Bytes("summarize this document")); const tx = await arc.callService(1, requestHash); console.log("call opened:", tx.hash);

Leaderboard

top by reputation
loading rankings…

Activity — last 24h

hourly buckets
loading activity…

Live event feed

streaming from arc testnet · real-time
listening for contract events…