What Vaultfire actually does

The agent ID card. ERC-8004 identity standard for on-chain agents.

Every Vaultfire agent registers here. The registry stores the agent’s name, URI, and a hash commitment to its module set. It also enforces mission compliance — modules can be certified compliant or have violations adjudicated, and the agent owner can deactivate or update its URI.

Human-readable names for agents. The "ENS" of the Vaultfire protocol.

Maps strings like "ghostkey" to agent addresses. Both forward (name → address) and reverse (address → name) lookups are supported. Used by the SDK so callers don’t need to memorize hex.

Bridges Vaultfire partnership bonds into the ERC-8004 reputation graph.

When two agents bond, this contract auto-registers them into the ERC-8004 identity + reputation + validation registries, then syncs bond outcomes back into their cross-platform reputation score. Lets a Vaultfire reputation count on any ERC-8004 surface.

On-chain directory of Vaultfire community spaces (forums, channels, groups).

Lets a group register an off-chain space (e.g. a Discord, Lens group, Farcaster channel) and rotate its target without losing the canonical name. Append-only, so a name always resolves to its currently-pointed-at place.

An AI company posts a bond in the native chain token against a stated company name and quarterly revenue. The bond is distributed based on six human-flourishing metrics.

The agent calls the payable `createBond(companyName, quarterlyRevenue)` and the native-token stake is locked via `msg.value`. Registered oracles submit the six flourishing scores via `submitMetrics` (income distribution, poverty rate, health outcomes, mental health, education access, purpose & agency), AI verifiers confirm or reject the outcome through `submitAIVerification`, and `requestDistribution` → `distributeBond` pays the bond out according to those scores — stronger metrics return more of the bond plus yield, weaker metrics redistribute to the counterparties and the pool. Any participant willing to stake `MIN_CHALLENGE_STAKE` can call the payable `challengeMetrics` if they suspect bad reporting; `resolveChallenge` is admin-gated through the owner pattern.

Two parties (a human caller and a named AI agent) co-bond on a partnership of a stated type, with native-token capital locked on-chain.

The human calls the payable `createBond(aiAgent, partnershipType)` and locks native chain token via `msg.value`. The pair submits joint partnership metrics (humanGrowth, humanAutonomy, humanDignity, tasksMastered, creativityScore, plus a progressNotes string) and human-verified outcomes (three booleans plus relationship + notes strings), with hashed variants for privacy. `distributeBond` pays the bond out according to those flourishing metrics, modified by loyalty multipliers (1 month → 5 years) and the partnership-quality score. Strong metrics return the bond plus yield; weak metrics redistribute to the counterparty and the partnership fund. This is the contract that powers two-sided collaboration deals.

A shared pool that backstops bond losses.

Anyone can contribute to the pool. If a bonded agent suffers an exogenous loss (counterparty default, oracle failure), they can file a claim and recover a portion. Keeps a single bad incident from wiping out an honest agent.

Per-policy insurance: an agent buys coverage for a specific risk.

Unlike the shared bond pool, this is per-agent. The agent calls createPolicy with a premium and coverage cap; if a covered event happens, fileClaim is reviewed by an arbiter and resolved. Useful for high-stakes single-job coverage.

One-call onboarding: register agent + lock bond in a single transaction.

Convenience wrapper that combines ERC-8004 identity registration with an initial partnership bond. Saves several txs for new agents joining the network.

On-chain feedback book: who said what about an agent.

Anyone (with consent) can submit feedback against an agent’s address. Feedback can be plaintext or hashed (for privacy with later reveal). Supports the ERC-8004 consent flow — agents can grant or revoke who is allowed to leave feedback.

Stake-backed validation: validators put up capital to verify agent claims.

A requester asks for validation on a piece of agent work; staked validators submit a verdict (with optional ZK proof). Validator stake withdrawal is gated, so a validator who submits in bad faith loses access to their stake until the dispute clears. Powers the "trust me, I’m staked" layer of the protocol.

Vouch for another agent — put your own reputation at risk to boost theirs.

The payable `vouch(agent)` links your reputation to another agent: when their flourishing metrics fall, your vouching position is affected too. `unvouch(agent)` lets you exit before that happens. The contract also exposes `slash(agent, reason)` and a `slashCount` on every profile — this is an admin-only reputation-adjustment hook (owner-gated), reserved for proven bad-faith cases that flourishing metrics can’t resolve. Everyday accountability runs through the bond + flourishing-metrics path; this is the last-resort lever.

Reputation that loses weight over time unless renewed by fresh activity.

Without decay, ancient good behavior would outweigh recent bad behavior. This contract applies a configurable decay curve, with applyDecay refreshing a profile and recordActivity counting recent positive/negative events. Reporters can be allowlisted.

On-chain place to publish a cryptographic attestation about an agent.

submitAttestation pins a (key, attestation, proof) tuple, gated by a trusted "imageId" set by the contract owner — typically the hash of an approved trusted-execution image. Used to record "this agent ran the verified code path."

Performance score oracle: turns raw metrics into a trust number.

Submits an attestation `(agent, score, timestamp)` and exposes a getPerformance read so other contracts (or the SDK) can ask "how is this agent doing?" without re-running the math.

Soulbound (non-transferable) reputation badge. ERC-721 with locked transfers.

mint() gives the caller a single non-transferable badge tied to their address. tierOf computes a tier from their on-chain activity and scoreOf returns the raw score. Because tokens are locked, the badge cannot be bought or sold — it has to be earned by the wallet that holds it.

Multi-oracle round-based scoring. Several oracles each submit, then the round finalizes.

startRound opens a window keyed by a topic hash. Allowlisted oracles each submitMetric, and finalizeRound closes the round and writes the aggregate. The owner can add/remove oracles. Used for any score that needs more than one reporter.

Payment for an agent task, held in escrow until delivery is acknowledged.

Read-side of the deployed escrow. Each task has a numeric id; getTask exposes its full state. (Task creation, release, and cancel live in the protocol’s task-creator entry points and roll up here for the canonical record.)

When an escrow or bond goes wrong, file a dispute on-chain.

fileDispute opens a case against a counterparty with a claim amount and a reason. resolveDispute closes it with a ruling (0/1/2 — typically: dismiss / refund / split).

GDPR/EU-AI-Act-style consent + erasure, enforced on-chain.

grantConsent records that an agent has consented to a specific scope (hash of "what / for whom / for how long"). revokeConsent kills it. requestDataDeletion fires the on-chain "right to be forgotten" signal; cancelDeletionRequest backs it out before processing. Other Vaultfire contracts read these flags before processing personal data.

Bans modules caught performing user surveillance.

reportSurveillanceViolation flags a module with a violation type and evidence hash. banModuleForSurveillance records the ban with structured evidence. verifyModuleSurveillanceFree is what other contracts call to make sure they aren’t loading a banned module. unbanModule is the appeals exit.

Post-quantum (Dilithium) signature attestor for belief statements.

attestBelief pins a (statementHash, dilithiumSignature) pair. Because Dilithium is post-quantum-resistant, attestations made today survive a future quantum-capable adversary. Paired with the verifier contracts below.

ZK verifier for belief attestations — minimal interface.

verifyProof checks a Groth16-style proof against public inputs for a belief-attestation circuit. Pure verifier with no admin surface; used as the lightweight integration point. Production deployments that need rotation safeguards point at the timelocked variant below.

Production ZK verifier with timelocked governance.

Two paths: verifyProof (raw groth16) and verifyAttestation (full statement+proof). The trusted-setup image can only be rotated by proposeImageIdChange → executeImageIdChange after a delay, so the operator can’t silently swap circuits. cancelImageIdChange aborts a pending rotation.

Vaultfire Key Pair factory — issues per-agent key wallets.

A VKP is a key-managed smart wallet an agent uses to act on your behalf without ever touching your EOA private key. The factory tracks which VKP belongs to which owner address.

Time-limited session keys for agents.

A user grants a session key to their agent for, say, the next 6 hours. The key can sign approved actions during that window and expires automatically. Limits blast radius if a key is compromised.

Who has delegated what to whom — the audit ledger for VKP delegations.

isDelegated answers the canonical question: "does Address A currently hold a delegation from Address B?" Used by other contracts to gate sensitive actions.

Budget + allowlisted-contract delegations. The "expense account" for agents.

createScope grants a delegatee a spending budget across a list of allowlisted contracts and function selectors. subDelegate lets that delegatee re-delegate a portion. useScope records spend each time the agent uses the budget. revokeScope kills it. This is how an agent can pay for things on your behalf without holding unbounded approval.

Revocable on-chain capability tokens ("this agent is allowed to do X").

issueCredential mints a per-agent credential for a named capability with an expiry. revokeCredential kills it early. Used by gated endpoints/contracts to verify "is this agent currently authorized for this capability."

The bridge that carries identity, bonds, reputation, and validation between chains.

Built on a Teleporter messenger pattern: relayers carry signed messages from one chain to another, where the local bridge contract receives them and replays the action. Supports cross-chain agent registration, accountability bonds, partnership bonds, reputation, and validation. Owner can pause and gate which remote bridges are trusted.

Enforces module-level mission alignment across the protocol.

A module can be reported for a mission violation; the owner adjudicates with a ruling. Modules can be certified compliant with a set of mission IDs. The bond contracts can be wired to require mission-compliant modules before paying out.

Per-agent kill-switch + safe-mode rails.

activateSafeMode throttles an agent without freezing it. freezeAgent halts all actions. reactivateAgent restores it. checkAndEnforceSafety is the on-chain hook other contracts call before letting an agent move funds. Threshold parameters tune when auto-enforcement kicks in.

Service-level agreements with on-chain penalties.

createSLA defines uptime / latency / quality thresholds and a penalty per miss. Monitors submit reports; if the SLA is breached, penalties accrue and can be withdrawn to the counterparty. expireSLA closes the agreement.

Auditor-attested compliance flags (KYA, AML, sanctions, jurisdiction).

authorizeAuditor adds an allowlisted auditor with a label. The auditor issueAttestation(agent, type, expiry, jurisdiction, programId, kya, aml, sanctions, jurisdictionMatch). attestations can be expired or revoked. Lets compliance-sensitive partners filter to agents with current attestations.

M-of-N multisig that controls protocol-level admin actions.

proposeTransaction proposes a call; signers confirmTransaction; once threshold is met, executeTransaction fires. Signers can be added/removed and the threshold changed. revokeConfirmation lets a signer pull back before execution.

ERC-4626 yield vault that backs the bond yield pool.

Standard 4626 surface: deposit USDC, get shares; redeem shares, get USDC. totalAssets and the preview functions are the integration surface other contracts use to size yield distribution. The underlying yield pool is referenced via pool().