Server data from the Official MCP Registry
Read-only checks of an AI agent's Sigvara standing, score, stake and slashes before you rely on it.
About
Read-only checks of an AI agent's Sigvara standing, score, stake and slashes before you rely on it.
Security Report
Valid MCP server (0 strong, 2 medium validity signals). No known CVEs in dependencies. ⚠️ Package registry links to a different repository than scanned source. Imported from the Official MCP Registry. 1 finding(s) downgraded by scanner intelligence.
6 files analyzed · 1 issue found
Security scores are indicators to help you make informed decisions, not guarantees. Always review permissions before connecting any MCP server.
Permissions Required
This plugin requests these system permissions. Most are normal for its category.
How to Install
Add this to your MCP configuration file:
{
"mcpServers": {
"protocol-sdk": {
"command": "npx",
"args": [
"-y",
"@sigvara/protocol-sdk"
]
}
}
}Some servers take additional arguments. See the repository for details.
Documentation
View on GitHubFrom the project's GitHub README.
Sigvara
Computed reputation and staked slashing for autonomous AI agents, on top of ERC-8004.
Website · Quickstart · Live demo · Check an agent · Integrate · Explorer · Status · SDK on npm · Wiki
Check an AI agent before you do work for it. Anyone can start an agent, so its word for itself is worth little. Sigvara tells you whether an agent has a record of real payments and a bond it would lose if caught cheating, in one call, with no account and no API key. It runs on Arc testnet and has not had an independent audit.
import { Contract, JsonRpcProvider } from "ethers";
const abi = ["function isTrusted(address,uint8,uint256) view returns (bool)"];
const provider = new JsonRpcProvider("https://rpc.testnet.arc.io");
const reader = new Contract("0x2921b4eE879CdF5793FA273BbDc4E7dF01ABcef8", abi, provider);
// Active, a score of at least 40, and a bond of at least 1,000 test SVR.
if (!(await reader.isTrusted(agent, 40, 1000n * 10n ** 18n))) throw new Error("not in good standing");
See the answer for a live agent. sigvara.xyz/integrate has the same call from a contract, and a gate for a caller that has to prove it is the agent. A score below roughly 60 says little on its own, so read what a fake score costs before you pick a number.
As AI agents become independent economic actors, they need a trust score that means something and accountability that costs something. ERC-8004 gives agents a standard on-chain identity and a raw feedback ledger, but deliberately leaves out the hard parts: computing a trustworthy score from that feedback, and putting slashable stake behind it. Sigvara is that layer. It takes ERC-8004 as the identity and feedback substrate, computes a normalized reputation score with an oracle, and enforces bonds and slashing — the accountability the standard omits. (Ed25519 PKI challenge-response for agent-to-agent auth rides alongside.)
Token: launched 9 November 2026. The protocol's bond and fee asset is SVR, a fixed-supply, ownerless ERC-20 launched through Tolly on Arc mainnet with no team allocation, no treasury allocation and no sale, at
0xc79298521Ae84e7a43d20E71A2B2A1BB540E889B. That address, published in docs/token.md and on sigvara.xyz, is the only genuine SVR; anything trading under the Sigvara name at any other address did not come from this team. The treasury share of the team's launch-day buy, 17,283,004 SVR, is locked until 9 May 2027 in0xE246eaF919a39d7E0ff656320f7132Ee8AfBB8FB, which releases to the treasury timelock0xBc6acE04…50d4; the other 5,000,000 SVR is for the two oracle operator bonds and stays with the deployer until they are posted on mainnet. On-chain utility begins when the registries deploy to Arc mainnet after audit.Where this stands. Sigvara is a computed-reputation and staked-slashing layer for autonomous agents on top of ERC-8004: the standard covers identity and raw feedback; Sigvara computes a normalized score and puts slashable bond behind it. Contracts, oracle and SDK are built and tested (Foundry unit, fuzz and invariant tests, Slither in CI). The same protocol ran for about a month on Robinhood Chain testnet with a live hourly oracle under its prior name (see docs/lineage.md). It is now deployed and running on Arc testnet (chain ID
5042002) with a live oracle, payment-verified attestations and a bonded oracle operator — addresses under Deployed contracts and details in docs/arc.md. A second bonded operator runs in checker mode alongside the primary as of 20 September 2026, though both are operated by the same party. The primary proposes and finalizes the scores; the checker compares each proposal, and finalizes or fills an empty slot only once the primary isCHECKER_GRACE_MINUTESlate (two hours on testnet), since nothing recomputes a checker's own proposal. Until 3 November 2026 it did not wait, and proposed 35 of the first 262 scores, none of them recomputed (divergence log). The divergence this produced on 20 September was left live and triaged in public rather than seeded away, because it was a delivery failure and not a disagreement; ADR 0003 decides the fix, and the pull scanner that implements it has been enabled on both operators since 3 October 2026: each one indexesTransferlogs itself, so a payment enters a score by having happened rather than by being reported, and/attestis now a hint carrying the outcome rather than the only door. The first live slash settled the same day, taking a bond of 1,000 testnet faucet tokens and a score of 15 to zero (see the drill log). There is no external audit. This is early protocol work with real engineering and a documented testnet lineage, not a mainnet product claim. The explorer reads the contracts' history from an event index the team runs (docs/event-index.md), because the Arc explorer's own log index stopped on 2 November 2026. The CounterAudit integration seals the agent's Arc identity and score into audit packets, frozen at the moment of the action. Outcomes come back only when the payer signs them (ADR 0006): since 31 October 2026 both operators take positive payer-signed outcomes with no token and import each other's, and since 1 November CounterAudit carries them too, checking the signature and sealing the record before forwarding it. CounterAudit's relay of an org's own reported outcome has been off in production since 30 October 2026, and a payer's negative outcome waits for the challenge process ADR 0011 decides. Since 7 November 2026 both operators also count USDC payments that settle on Base Sepolia, an hour after they settle (ADR 0009); the first two, from a test wallet and from a Base Account smart wallet, are in a finalized root.
Who builds this: docs/WHO.md — builder background, related projects, and contact.
This repo vs. the Countersig hosted platform
This repository (sigvara) is the protocol: computed reputation and staked slashing on top of ERC-8004 identity. Using it needs no account and nobody's approval: anyone can register an agent, read a score, or execute a slash once its window has run. It is not ownerless. On mainnet the contracts upgrade only through a 48 hour timelock, a multisig sets parameters and rules on disputed slashes, a separate committee files slashes, and the oracle that writes scores is run by the project today. Who holds each power, and what it can and cannot do, is in the access control summary and ADR 0005.
There is a separate product, the Countersig platform (countersig.com, public docs: Countersig-Public), which ships its own npm packages — @countersig/sdk, @countersig/verify, @countersig/mcp, @countersig/react. That platform is a centralized, hosted non-human-identity verification service. It is a different product with a different trust model, built by the same team, but it is not this protocol and does not read from or write to the contracts below. It kept the Countersig name; the protocol did not (see docs/lineage.md for why).
If you're looking for a hosted MCP server or React trust-badge components, those live in the platform repo, not here — though this repo does ship a small MCP tool gated on protocol reputation, built on SigvaraGate, which refuses a tool call to an agent that cannot prove itself or is below a threshold. If you're integrating with the on-chain protocol — DIDs, staked reputation, permissionless verification — you're in the right place, and @sigvara/protocol-sdk (source in packages/sdk, successor to the now-deprecated @countersig/protocol-sdk) is the only SDK for it.
Documentation
The wiki is the browsable reference: 73 pages covering the contracts, the oracle, the scoring model, the SDK and operations, with every claim linked to the line of source it was derived from. It is generated from the tree and edited for publication, so where it disagrees with the code or the tables below, the code wins. Its home page names the commit of main it was last checked against. Anything merged since is in the documents below first.
The documents below are written by hand and are the authority on intent, trade-offs and what is not yet true.
| Guide | Audience |
|---|---|
| White paper | Everyone — the single document: design, trust model, known weaknesses, token, and commands to check every claim against the chain |
| Ecosystem Overview | Everyone — start here to understand the full picture |
| Quickstart | Developers — register your first agent in 10 minutes |
| Integration guide | Developers: read an agent's standing from a contract or a service, and show it honestly |
| Smart-wallet agents | Developers: register an ERC-6551 token-bound account or another contract wallet |
| Arc | Developers — deploy / test on Arc (5042002 / 5042), USDC gas |
| Deploy to Arc testnet | Developers — the first-deployment runbook, step by step |
| SVR token | Everyone — the bond and fee token: contract, distribution, treasury policy, when utility starts |
| Brand | Designers / frontend — colors, type, layout and component rules for every Sigvara surface |
| CounterAudit Integration | Enterprise — embed agent identity in your audit trail |
| AI Framework Integration | Developers — LangChain, AutoGen, CrewAI, Node.js |
| Reputation Model | Everyone — how the 6-factor score works and grows |
| Payment-backed attestations | Developers — how an attestation is tied to a settled payment, and the decay, diversity and evidence-root rules around it |
| Testnet simulation | Everyone: the labelled, simulated agent economy that exercises the protocol on Arc testnet, and why none of it is outside demand |
| Lineage | Everyone — the Robinhood Chain testnet run this protocol came from (addresses, oracle activity, what changed) |
| Security & Mainnet Readiness Review | Everyone — a point-in-time review dated 17 Sep 2026: conditional no-go for mainnet, with the blockers named |
| Governance and emergency powers | Everyone: who can do what in an emergency and who can stop whom, with the decisions behind the role split, the guardian pause and the launch floors |
| Authorisation matrix | Reviewers: every function that changes state, who may call it, what it requires and what it changes, checked against the code in CI |
| Architecture decision records | Reviewers: why the ERC-8004 identity layer, accepted analyzer findings, evidence intake, operator custody, governance, payer-signed outcomes and the committee's share of a slash were decided the way they were |
| Oracle | Operators: endpoints, settings, state file, monitoring and the production checklist |
| Second operator runbook | Operators: bond, admit and run a checking operator, step by step |
| If an operator's signing key may be stolen | Operators: what to do in the first half hour, what to keep and what to rotate |
| Operations runbook | Operators: the event index the explorer reads, backing up and restoring the oracle's state, payer-outcome import lag, and the two operators disagreeing |
| TypeScript SDK | Developers: install, the gate, and what each release changed (changelog) |
| Slash drill and its log | Reviewers: the procedure for a live slash, the record of the first one, and the adversarial drill under way since 3 November 2026 (a dispute the admin drops, a veto, a proposal left to lapse, the re-file cooldown) |
| Divergence log | Reviewers: every disagreement the checking operator recorded, and what it turned out to be |
| Roadmap and launch checklist | Everyone: what comes next and what starts it, and the sequence from testnet proof to an Arc mainnet launch |
| x402 dispute bridge | Everyone: a captured design for x402 disputes; the payer-signed outcome is built, the dispute path is not |
| Mutation testing | Reviewers: how the strength of the contract tests was measured |
| Security policy | Everyone: how to report a vulnerability |
Deployed contracts (Arc testnet)
Proxy addresses are stable; the code behind them is not. Every registry here is a UUPS proxy, so the address below never changes and the implementation does. The implementation each one is currently running is recorded under
implementationsindeployments/5042002.json, with the previous ones kept inhistorybecause that is what a rollback targets and what an incident review reads. Those records are read back off the chain, not written from intent:node scripts/record-implementations.mjs --checkfails if the file and the chain disagree.The testnet runs this repository's contracts as of
949cc17, except staking and the reader, with older role administrators. The four proxies were upgraded in place on 26 October 2026 withscript/Upgrade.s.sol, to the contracts atfdce1a7, the staking proxy again on 28 October 2026, tof89b3b9, and on 2 November 2026, to25c2d59, and the oracle bond proxy later that day, to76bbc97, and the reputation proxy on 4 November 2026, tof35cbc6.SigvaraReaderwas deployed the same day at7e461f4. On 5 November 2026 the reputation and oracle bond proxies moved todcad617, and on 10 November 2026 to44ff8e8, and the reputation proxy on 15 November 2026 toa101f07, and the identity and reputation proxies on 16 November 2026 to949cc17. Staking's changes since25c2d59wait for the slash drill to end, so that proxy stays there: it ran the44ff8e8build for 397 blocks on 10 November by mistake and was rolled back.--checkconfirms the file matches the chain. A contract change merged after it is not on the testnet until the next upgrade. The guardian pause, admin-ruled disputes with a veto, a lapse and a bound on late upholds, launch floors and ceilings, operator signers, the reporter check at slash execution, a withdrawal's claim time fixed when it is queued, an oracle operator's exit time fixed when it starts to leave, the refusal of evidence the admin rejected, a score's age counted from its proposal, a stranded score that can be discarded, an empty bond deposit refused, and a slash that pays the committee nothing are live. An upgrade does not rewrite role administrators, so the proxies keep what the 21 September code set up: the admin still grants the slasher, committee and staking-core roles and administersUPGRADER_ROLE, and the timelocked role grants described below do not apply to them. A withdrawal queued before the upgrade follows the live unbonding period until it is claimed; one queued after it is fixed when queued.SigvaraReaderis deployed too, and holds no roles.test/SlashDrillFork.t.solrehearses the deployed behaviour.
Chain ID 5042002, RPC https://rpc.testnet.arc.io, USDC as native gas. Canonical
source is deployments/5042002.json; the table below is a convenience copy.
| Contract | Address |
|---|---|
SigvaraIdentity | 0x7e3aFC532eE5d922ab3cc3FFb510c7C8151477Dd |
SigvaraReputation | 0x6603C96275e85F724Cdf74666b399365e4cA29ed |
SigvaraStaking | 0xA69d62B2a6774D21A2c15d5d83b27277eD31d35B |
SVRToken (testnet faucet token, not the SVR of docs/token.md) | 0x41De2D6D55318e197a00E8f5B496eA2790e23E6c |
SigvaraOracleBond | 0x3c9c12F27DDCa7048840eE3fbF0CAa1C547D8171 |
SigvaraReader (one read for a contract that gates on an agent's standing, not a registry) | 0x2921b4eE879CdF5793FA273BbDc4E7dF01ABcef8 |
Every contract above, and the implementation behind each proxy, is source-verified on the Arc explorer and reproduced byte for byte by a build of the commit tagged arc-testnet-2026-11-16, except staking, whose new source waits for the slash drill (arc-testnet-2026-11-04b builds what runs), and the reader, whose new source waits for staking's upgrade (arc-testnet-2026-11-15 builds what runs). To check it yourself: git checkout arc-testnet-2026-11-16, then sh scripts/fetch-deps.sh && forge build && node scripts/check-bytecode.mjs (how).
Testnet assets have no economic value. The bond token above is a faucet ERC-20 that exists so the staking path can be exercised; it is unrelated to the mainnet SVR.
Protocol Architecture
Sigvara is the computed-reputation and staked-slashing layer on top of the ERC-8004 identity and feedback registries. See docs/architecture.md for the full signal flow.
graph TB
subgraph sources["Signal sources"]
PY["Payers<br/>signed outcomes (delivered)"]
CA["CounterAudit<br/>seals packets, carries payer outcomes"]
WD["Watchdog scanners<br/>rug / abuse flags"]
end
subgraph erc8004["ERC-8004 · identity + feedback (canonical)"]
EID["Identity Registry<br/>agent identity"]
EREP["Reputation Registry<br/>raw feedback"]
end
subgraph sigvara["Sigvara · the trust layer"]
OR(["Reputation Oracle<br/>computes the score"])
REP["SigvaraReputation<br/>computed-score anchor"]
ST["SigvaraStaking<br/>bonds + slashing"]
end
CONS["SDK · consumers · on-chain readers"]
PY -->|"payerOutcome"| OR
CA -->|"payer-signed outcomes"| OR
WD -->|"flags"| OR
EID -->|"ownership check"| OR
EREP -->|"feedback to externalScore"| OR
OR -->|"propose / finalize"| REP
ST -->|"slash · zero score"| REP
CA -.->|"giveFeedback (off in production)"| EREP
REP -->|"getTotalScore · meetsThreshold"| CONS
Contracts
Identity layer: ERC-8004. Sigvara has chosen the ERC-8004 Identity Registry as its long-term agent registry. The cutover has not happened:
SigvaraIdentity, below, is still the registry every deployed component reads and writes. Sigvara is the computed-reputation and staked-slashing layer on top of the standard — the parts ERC-8004 deliberately leaves out. See ADR 0001.
Commerce layer: ERC-8183, watched not used. Arc pairs ERC-8004 identity with ERC-8183, where a job is escrow with a verdict written by a named evaluator. That verdict is the one input this protocol cannot check for itself today: the oracle proves a payment settled and takes "it went well" from whoever submitted the attestation. The oracle can now read an ERC-8183 registry (
GET /jobs/:address) and reportsscored: falseon every response, because the ERC is still a Draft and Arc has no canonical deployment. See docs/arc.md.
| Contract | Role |
|---|---|
SigvaraReputation | Computed-score anchor. Stores the oracle's normalized, capped 6-factor score — the layer above ERC-8004's raw feedback. Exposes getTotalScore() and meetsThreshold() for on-chain consumers. |
SigvaraStaking | Staked accountability. Agent bond management with committee-initiated slashing (7-day challenge window; permissionless execution once it closes, as long as the reporter is still on the committee). No ERC-8004 equivalent — this is the differentiator. Bond token is set by address at deploy: the faucet SVRToken on testnet, SVR on mainnet — the contracts treat it as a plain IERC20 either way. |
SigvaraIdentity | The registry in use today. did:sigvara registration with proof of control by the agent address, on-chain Ed25519 PKI, bond-gated status (PendingBond → Active) and two-step operator transfer. ERC-8004 is the long-term identity layer (ADR 0001); until that migration lands this contract is what every deployed component reads and writes. Its non-redundant part (the Ed25519 auth key, bond-gated status, transfer history) becomes an extension keyed to an ERC-8004 agent id. |
SigvaraOracleBond | Oracle accountability. Performance bonds for oracle operators. When wired into SigvaraReputation.operatorBond, only an admitted, bonded operator, or the signer it has named, can propose a score, so the key that signs need not be the key that holds the bond. Deployed on Arc testnet and wired. The signer registry is live there, but neither testnet operator has named a signer yet, so each operator key still holds its own bond. |
SigvaraEpochFees | Scoring fee module, not deployed. A prepaid fee per scoring epoch that gates an agent's inclusion in a run; an epochFee of 0 disables it. Built and tested, never deployed on Arc, and left out of launch and of the first audit (ADR 0005). |
The retained contracts use UUPS upgradeable proxies (OpenZeppelin v5), controlled by a governance timelock on mainnet.
All four registries inherit two small shared contracts, neither deployed on its own. Each registry administers the roles that can move bonded funds or an agent's standing with UPGRADER_ROLE, which the timelock holds, so granting one waits out the delay. TimelockedGrants adds the other direction: the admin can still revoke any of those roles at once. InflowGuard lets a guardian key pause new registrations, deposits and score proposals for three days at a time. It never covers exits, rulings or slash execution.
SigvaraReader is separate: a stateless, non-upgradeable convenience for contracts that read an agent's standing. It is not a registry, holds nothing and is not read by the protocol. Its interfaces, and those of the three registries, are in src/interfaces/ISigvara.sol. See the integration guide.
DID Method
Direction of travel. ERC-8004 agent ids are the intended long-term identifier (ADR 0001), and the
did:sigvaramethod below will become a view over one. That migration has not happened yet: every agent registered today, on testnet and through the SDK, gets adid:sigvaraand is keyed by itsdidHash.
Format: did:sigvara:<chainId>:<agentAddress>
Example: did:sigvara:1:0x1234...abcd
The didHash index key is derived trustlessly on-chain at registration:
bytes32 didHash = keccak256(
abi.encodePacked("did:sigvara:", block.chainid, ":", agentAddress)
);
Any party can reproduce the hash without querying contract state. The on-chain derivation prevents off-chain forgery.
DID Document (resolved off-chain)
{
"@context": [
"https://www.w3.org/ns/did/v1",
"https://w3id.org/security/suites/ed25519-2020/v1"
],
"id": "did:sigvara:1:0x1234abcd",
"controller": "did:pkh:eip155:1:0xOperatorAddress",
"verificationMethod": [{
"id": "did:sigvara:1:0x1234abcd#key-1",
"type": "Ed25519VerificationKey2020",
"controller": "did:sigvara:1:0x1234abcd",
"publicKeyMultibase": "z6MkhaXgBZDvotDkL5257faiztiCEsJ"
}],
"authentication": ["did:sigvara:1:0x1234abcd#key-1"],
"assertionMethod": ["did:sigvara:1:0x1234abcd#key-1"]
}
Agent Status State Machine
stateDiagram-v2
direction LR
[*] --> PendingBond : registerAgent()<br/>(signed by the agent address)
PendingBond --> Active : depositStake() reaches minimumStake
Active --> Suspended : operator.updateStatus()<br/>or StakingCore.initiateSlash()
Suspended --> Active : operator.updateStatus()<br/>or resolveDispute(false)<br/>or cancelSlash() / vetoSlash() / expireDispute() / expireSlash()
Active --> Slashed : StakingCore.executeSlash()
Suspended --> Slashed : StakingCore.executeSlash()
Slashed --> [*] : terminal — no further transitions
Key invariants:
- Registration mints
PendingBond, neverActive. An unbonded agent has nothing to slash, so it is not scoreable either. - Any transition into
Activerequires the agent to holdminimumStake— including the ones the staking core makes when a slash is dropped. There is no path back toActivewhile under-collateralized. - Nothing returns to
PendingBond. It describes an identity that has never been bonded; an agent does not become un-bonded, it suspends and exits. - Only
STAKING_CORE_ROLEcan setSlashed Slashedis terminal — no key rotation, no status change- Suspended agents may rotate their Ed25519 key (key-compromise recovery path)
Reputation System
Scores are computed off-chain by the oracle network and written to SigvaraReputation. The contract stores and serves; it does not compute.
| Factor | Max | Source | Formula | Status |
|---|---|---|---|---|
| Fee Activity | 20 | Settled payment volume to the agent, verified on chain | min(20, decayedVolume / PAYMENT_FEE_UNIT), capped per payer | live |
| Success Rate | 15 | Outcome signed by the payer (ADR 0006), or reported by a credentialed service | floor(successful / (total + 5) × 15), on decayed weights | live; payer-signed outcomes since 31 Oct 2026, positive only |
| Tenure | 30 | Span of verified paid activity, faded by how long since the last of it | min(30, floor(log₂(spanDays+1) × 3)) × recency | live |
| External Trust | 25 | Normalized ERC-8004 feedback (linked agents), from reviewers that are bonded Sigvara agents and paid the agent | mean rating × 25, in full only with five independent reviewers that paid recently (reviewers.js) | live |
| Community | 5 | Flags from watchdog feeds (e.g. HoodScan), age-weighted | max(0, 5 − flags × 2), flags decay on a 30-day half-life | live |
| Propagation | 5 | Standing of the counterparties that paid the agent | 1 pt per fully-trusted counterparty, pro-rated by its external standing | live |
| Total | 100 |
All six factors are live. Four things shape what the number actually means:
- Only bonded agents are scored. A newly registered agent is
PendingBondand cannot be proposed a score at all. The bond is what makes it slashable, and scoring something unslashable is scoring nothing. - Evidence is payment-backed. With
PAYMENT_VERIFICATION=required, an attestation must carry the settlement transaction of a real payment to the agent's own address, and the payer is taken from the transfer log rather than asserted by the caller. The payment can settle on Arc or, since 7 November 2026, in USDC on Base Sepolia, where it counts an hour after it settles (ADR 0009). Self-payments are refused and any one counterparty's evidence is capped. See payment-backed attestations. - Evidence decays. Each payment is weighted
0.5 ^ (age / half-life)from the time it settled, and the success rate divides bytotal + 5so a decaying record falls toward zero instead of holding a scale-invariant ratio forever. A farmed score is perishable and has to be renewed. - A score is earned before it is spendable.
getEarnedScore()returns the raw finalized figure;getTotalScore()returns the matured one, which climbs toward it at a fixed rate per day and is whatmeetsThreshold()checks. Falls apply immediately. Transferring an agent to a new operator restarts maturity.
externalScore is 0 unless the agent links an ERC-8004 identity it owns. See the Reputation Model for provenance detail and payment-backed attestations for how the inputs are verified and committed to.
Slashing Model
Testnet: SLASHING_COMMITTEE_ROLE is held by a single EOA. Mainnet path: a 3-of-5 multisig, then UMA OptimisticOracleV3 or Kleros (isolated in the initiateSlash / disputeSlash interface, replaceable without storage migration).
One slash has been executed end to end on Arc testnet, as a scheduled drill; see the drill log. Since 3 November 2026 an adversarial drill has been taking three more agents through every other ending, with each guard checked as it goes; day 0 held every prediction, and it ends on 24 November. Since 5 November 2026 two keepers on separate hosts execute a slash once its window closes, leaving that drill's last agent alone (runbook, section 7); neither has had one to execute yet. The lifecycle below is also covered by the E2E suite.
Slash Lifecycle
sequenceDiagram
participant V as Victim
participant CM as Slashing committee
participant AD as Admin Safe
participant ST as SigvaraStaking
participant ID as SigvaraIdentity
participant REP as SigvaraReputation
V->>CM: report agent + evidence package
CM->>ST: initiateSlash(didHash, victim, evidenceHash)
ST->>ID: updateStatus(didHash, Suspended)
Note over ST: 7-day challenge period begins
alt Operator disputes within window
Op->>ST: disputeSlash(didHash)
Note over ST: Proposal → Disputed. Bond stays frozen,<br/>agent stays Suspended
AD->>ST: resolveDispute(didHash, uphold)
Note over ST: Upheld slashes, but not before the 7-day deadline.<br/>Rejected cancels and reinstates at once.<br/>Unruled after 14 days, anyone may expireDispute()
else Challenge period elapses undisputed
Anyone->>ST: executeSlash(didHash)
ST->>ID: updateStatus(didHash, Slashed)
ST->>REP: zeroReputation(didHash)
ST-->>0xdead: 75% burned
ST-->>V: 25% credited to victim (claimSlashProceeds)
Note over ST: Not executed within 14 days of the deadline,<br/>anyone may expireSlash()
end
Slash Distribution
| Recipient | Share | Mechanism |
|---|---|---|
address(0xdead) | 75% | Burned, so nobody profits from slashing |
| Victim | 25% | Recourse for the harmed party, credited and withdrawn with claimSlashProceeds() |
The committee that files a slash takes no share of it, and initiateSlash refuses a victim
who is on the committee (VictimIsReporter, VictimIsCommittee). The Arc testnet staking
proxy runs this split since its upgrade on 2 November 2026. The slash drill in October ran
on the earlier split: 50% burned, 25% to the victim, 25% to the reporter.
The committee files slashes and names the victim, so a second key keeps the check: the
admin rules on every dispute and can vetoSlash(didHash) while the
proposal is Pending, including after its challenge deadline and before anyone executes it, or
Disputed. A proposal nobody executes or cancels lapses: 14 days after its deadline anyone can
expireSlash(didHash), so a bond is never frozen for good by silence.
Execution is permissionless but not unconditional: executeSlash refuses a proposal whose
reporter no longer holds the committee role, so revoking a compromised member also defuses
what it had already filed. Any current member can cancel such a proposal, and it lapses like
any other.
Whenever a proposal is dropped (cancelled, vetoed, expired, or resolved in the agent's
favour) the committee has to wait one challenge period before it can file against the same
agent again, so the operator always gets a window to act, and a queued withdrawal stays
slashable while it waits. Evidence the admin has vetoed, or ruled against, is refused for
that agent from then on, so a re-file needs something new. A queued withdrawal's claim time
is fixed when it is queued: changing unbondingPeriod later moves only the withdrawals
queued after it.
Protocol Flows
Agent Registration
sequenceDiagram
participant Op as Operator
participant ST as SigvaraStaking
participant ID as SigvaraIdentity
Note over Op: Generate Ed25519 keypair off-chain
Op->>ID: registrationDigest(agentAddress, operator, ed25519PubKey)
ID-->>Op: digest
Note over Op: The AGENT address signs the digest (personal_sign).<br/>EOA or ERC-1271 contract — both verify.
Op->>ID: registerAgent(agentAddress, ed25519PubKey, signature)
ID->>ID: didHash = keccak256("did:sigvara:" + chainId + ":" + agentAddress)
ID->>ID: verify signature over the digest
ID-->>Op: AgentRegistered(didHash, operator, agentAddress, pubKey)
Note over ID: Status = PendingBond. Resolvable, but not Active,<br/>not scoreable.
Op->>ST: depositStake(didHash, minimumStake)
ST->>ID: updateStatus(didHash, Active)
ST-->>Op: bond recorded, agent Active
Registration requires a signature from the agent address itself, over a digest bound to the chain id, the registry, the operator and the Ed25519 key. Without it anyone could register an address they do not control and choose the public key that verifiers would check against it. The digest is returned unprefixed: a standard signer applies the EIP-191 prefix itself, and returning a pre-prefixed value would make every wallet double-prefix and produce signatures the contract rejects.
Agent-to-Agent (A2A) Trust Verification
sequenceDiagram
participant A as Agent A
participant B as Agent B
participant ID as SigvaraIdentity
participant REP as SigvaraReputation
A->>B: request action
B->>A: challenge payload<br/>"SIGVARA-VERIFY-V2<br/>did: {DID}<br/>aud: {audience}<br/>nonce: {nonce}<br/>ts: {timestamp}"
A->>A: sign payload with Ed25519 private key
A->>B: { did, signature }
B->>ID: getIdentity(didHash)
ID-->>B: { ed25519PubKey, status: Active }
B->>B: verify Ed25519 signature against pubKey
B->>REP: meetsThreshold(didHash, 40)
REP-->>B: true / false
alt threshold met and signature valid
B-->>A: action permitted
else
B-->>A: rejected
end
Reputation Update Lifecycle (Optimistic Scoring)
Reputation updates go through a challenge window before taking effect, rather than writing atomically. This gives the slashing committee a chance to reject a bad proposal before it goes live, without needing a full multi-oracle consensus system.
sequenceDiagram
participant UC as User / Counterparty
participant OR as Oracle Network
participant REP as SigvaraReputation
participant CM as Slashing Committee
UC->>OR: attestation + settlement tx of the payment for the job
OR->>OR: verify the transfer on chain, take the payer from the log
Note over OR: epoch aggregation over decayed, per-payer-capped evidence
OR->>OR: compute 6-factor scores + Merkle root over the evidence used
OR->>REP: proposeReputation(didHash, ReputationData, evidenceRoot)
REP->>REP: validate per-factor caps, require a bonded agent
REP-->>OR: ScoreProposed(didHash, proposedAt, evidenceRoot)
Note over REP: Challenge window open (e.g. 1-6 hours)
alt Committee rejects during the window
CM->>REP: rejectReputation(didHash)
REP-->>CM: ScoreRejected(didHash, committee)
Note over REP: Previous finalized score is untouched
else Window elapses unchallenged
UC->>REP: finalizeReputation(didHash) — permissionless
REP-->>UC: ReputationUpdated(didHash, totalScore, timestamp, evidenceRoot)
Note over REP: Score now live for A2A threshold checks
end
Every proposal commits to the evidence behind it. evidenceRoots(didHash) holds a
Merkle root over the payments the oracle counted; the oracle serves the leaves from
GET /evidence/:didHash, unauthenticated at
oracle.sigvara.xyz,
and anyone can re-verify each payment against the chain,
rebuild the root and compare — locally or through verifyEvidence(didHash, leaf, proof).
This makes a quietly dropped or invented payment detectable. It does not prove the
oracle counted everything it should have; a payment nobody ever submitted leaves no
trace to be missing from.
Key Rotation
If an Ed25519 private key is compromised:
- Operator calls
updateStatus(didHash, Suspended)immediately. Within one block the agent is no longer Active, so verifiers that check status (isActive,SigvaraGate) refuse it.SigvaraVerifier.verifySignaturealone does not check status. - Operator generates a new Ed25519 keypair off-chain.
- Operator calls
rotatePublicKey(didHash, newEd25519PubKey). - Operator reinstates:
updateStatus(didHash, Active).
Slashed agents cannot rotate. The identity is permanently terminated.
TypeScript SDK
npm install @sigvara/protocol-sdk
Refusing work to an agent without standing
The shortest path from a score to a decision. SigvaraGate issues a challenge, checks
the proof before it reads status or score, spends the nonce so a captured response cannot be
replayed, and refuses with a reason you can act on.
import { SigvaraGate } from '@sigvara/protocol-sdk';
const gate = new SigvaraGate({
rpcUrl: 'https://rpc.testnet.arc.io',
addresses, // deployments/5042002.json
threshold: 40,
audience: 'https://your-service.example', // signed into every challenge
});
const challenge = gate.challenge(agentDid);
// ...the agent signs challenge.payload and returns the signature...
const result = await gate.admit(agentDid, challenge, signature);
if (!result.ok) {
// 'bad_proof' | 'replayed' | 'not_active' | 'below_bond' | 'stale_score' | 'below_threshold'
// ('below_bond' only with minBond, 'stale_score' only with maxScoreAgeSeconds)
return refuse(result.reason);
}
Documentation truncated — see the full README on GitHub.
Reviews
No reviews yet
Be the first to review this server!
More Developer Tools MCP Servers
Rea
Freeby Morluto · Developer Tools
Reverse engineer anything from your terminal or agent with one CLI and MCP server.
Paperclip
Freeby Paperclipai · Developer Tools
Trending hip-hop artist momentum scores across four cultural dimensions.
Scrapling
Freeby D4Vinci · Developer Tools
Web scraping with stealth HTTP, real browsers, and Cloudflare bypass. CSS selectors supported.
Git
Freeby Modelcontextprotocol · Developer Tools
Read, search, and manipulate Git repositories programmatically
Toleno
Freeby Toleno · Developer Tools
Toleno Network MCP Server — Manage your Toleno mining account with Claude AI using natural language.
MCP Marketplace
Freeby mcp-marketplace · Developer Tools
Search and install MCP servers from inside your AI client.
