Back to Browse

Sigvara MCP Server

Developer ToolsLow Risk9.7MCP RegistryLocal
Free

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

9.7
Low Risk9.7Low Risk

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.

env_vars

Check that this permission is expected for this type of plugin.

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 GitHub

From 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 in 0xE246eaF919a39d7E0ff656320f7132Ee8AfBB8FB, which releases to the treasury timelock 0xBc6acE04…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 is CHECKER_GRACE_MINUTES late (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 indexes Transfer logs itself, so a payment enters a score by having happened rather than by being reported, and /attest is 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.

GuideAudience
White paperEveryone — the single document: design, trust model, known weaknesses, token, and commands to check every claim against the chain
Ecosystem OverviewEveryone — start here to understand the full picture
QuickstartDevelopers — register your first agent in 10 minutes
Integration guideDevelopers: read an agent's standing from a contract or a service, and show it honestly
Smart-wallet agentsDevelopers: register an ERC-6551 token-bound account or another contract wallet
ArcDevelopers — deploy / test on Arc (5042002 / 5042), USDC gas
Deploy to Arc testnetDevelopers — the first-deployment runbook, step by step
SVR tokenEveryone — the bond and fee token: contract, distribution, treasury policy, when utility starts
BrandDesigners / frontend — colors, type, layout and component rules for every Sigvara surface
CounterAudit IntegrationEnterprise — embed agent identity in your audit trail
AI Framework IntegrationDevelopers — LangChain, AutoGen, CrewAI, Node.js
Reputation ModelEveryone — how the 6-factor score works and grows
Payment-backed attestationsDevelopers — how an attestation is tied to a settled payment, and the decay, diversity and evidence-root rules around it
Testnet simulationEveryone: the labelled, simulated agent economy that exercises the protocol on Arc testnet, and why none of it is outside demand
LineageEveryone — the Robinhood Chain testnet run this protocol came from (addresses, oracle activity, what changed)
Security & Mainnet Readiness ReviewEveryone — a point-in-time review dated 17 Sep 2026: conditional no-go for mainnet, with the blockers named
Governance and emergency powersEveryone: 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 matrixReviewers: every function that changes state, who may call it, what it requires and what it changes, checked against the code in CI
Architecture decision recordsReviewers: 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
OracleOperators: endpoints, settings, state file, monitoring and the production checklist
Second operator runbookOperators: bond, admit and run a checking operator, step by step
If an operator's signing key may be stolenOperators: what to do in the first half hour, what to keep and what to rotate
Operations runbookOperators: the event index the explorer reads, backing up and restoring the oracle's state, payer-outcome import lag, and the two operators disagreeing
TypeScript SDKDevelopers: install, the gate, and what each release changed (changelog)
Slash drill and its logReviewers: 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 logReviewers: every disagreement the checking operator recorded, and what it turned out to be
Roadmap and launch checklistEveryone: what comes next and what starts it, and the sequence from testnet proof to an Arc mainnet launch
x402 dispute bridgeEveryone: a captured design for x402 disputes; the payer-signed outcome is built, the dispute path is not
Mutation testingReviewers: how the strength of the contract tests was measured
Security policyEveryone: 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 implementations in deployments/5042002.json, with the previous ones kept in history because 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 --check fails 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 with script/Upgrade.s.sol, to the contracts at fdce1a7, the staking proxy again on 28 October 2026, to f89b3b9, and on 2 November 2026, to 25c2d59, and the oracle bond proxy later that day, to 76bbc97, and the reputation proxy on 4 November 2026, to f35cbc6. SigvaraReader was deployed the same day at 7e461f4. On 5 November 2026 the reputation and oracle bond proxies moved to dcad617, and on 10 November 2026 to 44ff8e8, and the reputation proxy on 15 November 2026 to a101f07, and the identity and reputation proxies on 16 November 2026 to 949cc17. Staking's changes since 25c2d59 wait for the slash drill to end, so that proxy stays there: it ran the 44ff8e8 build for 397 blocks on 10 November by mistake and was rolled back. --check confirms 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 administers UPGRADER_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. SigvaraReader is deployed too, and holds no roles. test/SlashDrillFork.t.sol rehearses 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.

ContractAddress
SigvaraIdentity0x7e3aFC532eE5d922ab3cc3FFb510c7C8151477Dd
SigvaraReputation0x6603C96275e85F724Cdf74666b399365e4cA29ed
SigvaraStaking0xA69d62B2a6774D21A2c15d5d83b27277eD31d35B
SVRToken (testnet faucet token, not the SVR of docs/token.md)0x41De2D6D55318e197a00E8f5B496eA2790e23E6c
SigvaraOracleBond0x3c9c12F27DDCa7048840eE3fbF0CAa1C547D8171
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 reports scored: false on every response, because the ERC is still a Draft and Arc has no canonical deployment. See docs/arc.md.

ContractRole
SigvaraReputationComputed-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.
SigvaraStakingStaked 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.
SigvaraIdentityThe 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.
SigvaraOracleBondOracle 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.
SigvaraEpochFeesScoring 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:sigvara method below will become a view over one. That migration has not happened yet: every agent registered today, on testnet and through the SDK, gets a did:sigvara and is keyed by its didHash.

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, never Active. An unbonded agent has nothing to slash, so it is not scoreable either.
  • Any transition into Active requires the agent to hold minimumStake — including the ones the staking core makes when a slash is dropped. There is no path back to Active while 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_ROLE can set Slashed
  • Slashed is 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.

FactorMaxSourceFormulaStatus
Fee Activity20Settled payment volume to the agent, verified on chainmin(20, decayedVolume / PAYMENT_FEE_UNIT), capped per payerlive
Success Rate15Outcome signed by the payer (ADR 0006), or reported by a credentialed servicefloor(successful / (total + 5) × 15), on decayed weightslive; payer-signed outcomes since 31 Oct 2026, positive only
Tenure30Span of verified paid activity, faded by how long since the last of itmin(30, floor(log₂(spanDays+1) × 3)) × recencylive
External Trust25Normalized ERC-8004 feedback (linked agents), from reviewers that are bonded Sigvara agents and paid the agentmean rating × 25, in full only with five independent reviewers that paid recently (reviewers.js)live
Community5Flags from watchdog feeds (e.g. HoodScan), age-weightedmax(0, 5 − flags × 2), flags decay on a 30-day half-lifelive
Propagation5Standing of the counterparties that paid the agent1 pt per fully-trusted counterparty, pro-rated by its external standinglive
Total100

All six factors are live. Four things shape what the number actually means:

  • Only bonded agents are scored. A newly registered agent is PendingBond and 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 by total + 5 so 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 what meetsThreshold() 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

RecipientShareMechanism
address(0xdead)75%Burned, so nobody profits from slashing
Victim25%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:

  1. 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.verifySignature alone does not check status.
  2. Operator generates a new Ed25519 keypair off-chain.
  3. Operator calls rotatePublicKey(didHash, newEd25519PubKey).
  4. 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!