Economy Crates

Implementation owners

Each entry gives a workspace path, a responsibility, and the API symbols to search for. Use a type name to move from a documentation concept to its Rust definition.

Economy crates

Crate membership and paths are generated from the workspace manifests; each responsibility is written against the crate's module documentation.

chio-anchor

Publishes checkpoints to external chains and verifies the proofs that come back: EVM root-registry publication, Bitcoin super-root aggregation over OpenTimestamps, Solana memos, and fail-closed multi-lane proof-bundle verification. Its second mechanism, chio.anchor_batch.v1, Merkle-batches checkpoint ids against a public witness.

Source: crates/economy/chio-anchor

API: AnchorServiceConfig, AnchorError

chio-appraisal

Runtime-attestation appraisal and the deterministic marketplace invocation-pricing model, including the reputation-tier discount applied on top of advertised tool pricing.

Source: crates/economy/chio-appraisal

API: RuntimeAttestationAppraisalResult, MarketplaceReputationTier, MarketplaceBasePrice, MarketplaceInvocationPrice, MarketplacePricingContext

chio-autonomy

Contracts and validators for bounded autonomous pricing, capital-pool optimization, execution decisions, and rollback plans. These records reference the signed evidence and authority behind a proposed action; the crate does not run an autonomous execution service.

Source: crates/economy/chio-autonomy

API: AutonomousPricingInputArtifact, AutonomousPricingAuthorityEnvelopeArtifact, AutonomousPricingDecisionArtifact, CapitalPoolOptimizationArtifact, AutonomousExecutionDecisionArtifact, AutonomousRollbackPlanArtifact

chio-credit

Credit facilities, bonds, the capital book, the exposure ledger, credit scorecards, and the receivable-side primitives below. The accounting layer for delegated risk.

Source: crates/economy/chio-credit

API: CreditFacilityArtifact, CreditBondArtifact, CreditScorecardReport, ExposureLedgerReport, CreditLossLifecycleArtifact

chio-fincred

Wire-neutral financial credential contract types: the five credential families an agent carries across organizations, their verifier policy, and the thresholds a verifier applies to each.

Source: crates/economy/chio-fincred

API: FinancialCredentialFamilyV1, FinancialCredentialSubjectV1, FinancialVerifierPolicyV1, FinancialVerifierThresholdsV1

chio-finding

The signed cognition-market information good chio.finding.v1 and its supporting artifact families: challenge, audit epoch, purchase record, bond backing, and status feeds. This crate owns pure validation and signing. Callers provide storage, status-feed resolution, and runtime enforcement.

Source: crates/economy/chio-finding

API: Finding, FindingDescriptor, sign_finding, verify_finding

chio-fiscal

Governed fiscal charters and fee schedules: the signed terms that fix what a marketplace may charge, and the bond classes and collateral references the open market prices against.

Source: crates/economy/chio-fiscal

API: FiscalCharter, FiscalSchedule, VerifiedFiscalCharter, OpenMarketFeeScheduleArtifact

chio-link

Oracle backends, rate caching, freshness and circuit-breaker checks, and conversion evidence for cross-currency budgets. Chainlink and sequencer readers depend on the selected build features; installing a price oracle in the kernel is a separate runtime choice.

Source: crates/economy/chio-link

API: PriceOracle, ChioLinkOracle, ExchangeRate

chio-listing

The signed listing and namespace artifacts marketplace participants publish, the report-aggregation and discovery search paths that make them findable, and the local trust-activation flow that turns a discovered listing into an admissible one. It also owns the outcome-pricing family.

Source: crates/economy/chio-listing

API: Listing, SignedListingPricingHint, ListingSearchResponse

chio-market

The liability market: provider catalog, quote and bind flow, pricing-authority envelopes, claim packages, and adjudication.

Source: crates/economy/chio-market

API: LiabilityProviderArtifact, LiabilityQuoteRequestArtifact, LiabilityQuoteResponseArtifact, LiabilityBoundCoverageArtifact, LiabilityClaimAdjudicationArtifact

chio-metering

Per-receipt cost attribution, cumulative cost queries, billing exports, and organizational budget evaluation. Its process-local budget enforcer is deprecated; kernel budget reservations belong to the kernel's BudgetStore.

Source: crates/economy/chio-metering

API: CostDimension, CostMetadata, BillingExport, BudgetEnforcer, BudgetTree

chio-open-market

The open capability marketplace: the bid, ask and accept protocol that mints scoped capability tokens against published listings, and the fee-schedule and penalty state machines behind it.

Source: crates/economy/chio-open-market

API: SignedBidRequest, SignedAskResponse, SignedAcceptedBid

chio-settle

The settlement runtime over the web3 contract family: EVM escrow, Solana settlement, Chainlink CCIP cross-chain messages, x402 and ERC-4337 payment helpers, streaming payment channels, and watchdog automation.

Source: crates/economy/chio-settle

API: SettlementCommitment, PreparedEvmCall, CcipSettlementMessage, PreparedSolanaSettlement, X402PaymentRequirements, SettlementWatchdogJob

chio-underwriting

Risk classification, premium pricing, simulation, and decision outcomes for governed actions. It produces decision artifacts and the appeal lifecycle records that follow them.

Source: crates/economy/chio-underwriting

API: UnderwritingRiskClass, UnderwritingDecisionPolicy, UnderwritingDecisionOutcome, UnderwritingPremiumQuote, UnderwritingDecisionArtifact

chio-web3

The on-chain artifact shapes and their validators: signed identity bindings, trust profiles, contract packages, chain configuration, anchoring proofs, oracle FX evidence, and the settlement dispatch and execution-receipt lifecycle.

Source: crates/economy/chio-web3

API: Web3ContractKind, Web3ContractPackage, Web3SettlementLifecycleState, Web3SettlementDispatchArtifact, OracleConversionEvidence

chio-web3-bindings

The generated Rust ABI bindings and compiled JSON artifacts for the Solidity contract family that chio-web3 describes.

Source: crates/economy/chio-web3-bindings

API: IChioEscrow, IChioBondVault, IChioRootRegistry, IChioIdentityRegistry, IChioPriceResolver

Identity and platform dependencies

Markets compose with the rest of Chio's authority model. These crates supply the identity, trust, and tool-description contracts referenced throughout the Economy docs; their paths come from the same census.

chio-manifest

The signed tool manifest with its pricing and SLA hints. ToolManifest, ToolPricing, PricingModel, SignedManifest. The protocol adapters depend on it, not the kernel.

Source: crates/platform/chio-manifest

chio-reputation

Deterministic local scoring from a caller-supplied corpus of receipts, capability lineage, and budget records. LocalReputationCorpus, LocalReputationScorecard, ReputationWeights, ImportedReputationSignal.

Source: crates/trust/chio-reputation

chio-federation

Bilateral peer pinning, the federation activation exchange, cross-org reputation clearing, and quorum policy. FederationActivationExchangeArtifact, FederationQuorumReport, FederationAntiEclipsePolicy, FederatedReputationClearingArtifact.

Source: crates/trust/chio-federation

chio-credentials

Agent Passport verification and the portable reputation summary. AgentPassport, PortableReputationSummaryArtifact and its envelope SignedPortableReputationSummary, carrying schema chio.portable-reputation-summary.v1.

Source: crates/trust/chio-credentials

chio-did

Self-certifying did:chio identifiers and DID document resolution. The method-specific identifier encodes an Ed25519 public key as hexadecimal. DidChio.

Source: crates/trust/chio-did

Shared protocol types

chio-core-types defines capability, receipt, and canonical-JSON types without a dependency on another workspace crate in its runtime dependencies. Its source is crates/core/chio-core-types. chio-core re-exports these types together with domain APIs under one import path.

Kernel dependencies and runtime integration

The kernel manifest directly names five economy crates in its normal runtime dependency section:

• chio-appraisal
• chio-credit
• chio-link
• chio-settle
• chio-underwriting

Several other domain APIs are available through the kernel's dependency on chio-core. The following re-exports expose Rust modules; they do not install a service, admit a counterparty, or authorize a tool call.

pub use chio_appraisal as appraisal;
pub use chio_autonomy as autonomy;
pub use chio_credit as credit;
pub use chio_federation as federation;
pub use chio_governance as governance;
pub use chio_listing as listing;
pub use chio_market as market;
pub use chio_open_market as open_market;
pub use chio_underwriting as underwriting;
pub use chio_web3 as web3;

chio-anchor depends on the kernel to consume its checkpoint and evidence types. Anchoring is downstream of signed evidence. chio-metering is consumed by chio-data-guards; its presence in the economy directory does not make its budget enforcer the kernel's budget store.

PriceOracle integration

The kernel depends on chio-link, but its price_oracle field starts as None. An operator installs a Box<dyn PriceOracle> through set_price_oracle. When a cost requires conversion into a grant's currency, the kernel resolves a rate through that installed implementation. Without one, this conversion path returns NoCrossCurrencyOracle.

This separation lets deployments choose their oracle while keeping the currency-conversion requirement explicit at the budget boundary. See Chainlink Oracles for backend configuration and conversion evidence.

Receivables, netting, and payment channels

These mechanisms act on related economic records, but have different owners. Use the module boundary when choosing where to integrate. Chio Paper and the Clearinghouse are the factor and clearing modules of chio-credit, so there is no separate crate to add for either.

An obligation ID is derived from the economic-intent digest and source receipt digest. Assignment checks bind the atom to current status, expected versions and fences, and supplemental authorization. Those contracts give an integrating runtime the information it needs to reject conflicting assignments; constructing an atom alone does not prevent another system from making a duplicate claim.

Budget evaluation and budget state

Choose the budget API by the state it owns. A local counter, an organizational policy evaluator, and the kernel's reservation store solve different parts of spending control.

BudgetEnforcer: process-local counters

This chio-metering API checks total, session, agent, and tool limits, then updates its own in-memory counters through record. It is deprecated: counters reset on restart, and concurrent use needs external synchronization. The source directs callers to the kernel's BudgetStore for continuity across restarts.

BudgetTree: organizational policy

BudgetTree::evaluate checks proposed spend against a node and its ancestors, allowing organization, department, team, and agent caps to apply together. It consumes a caller-supplied SpendSnapshot and returns a BudgetDecision; it does not persist or reserve the spend. Missing evaluation time, stale windows, incompatible currency, or exceeded caps produce a denial. A node absent from the snapshot is treated as having zero current spend, so the caller must supply a complete accounting view.

BudgetStore: kernel reservations

The BudgetStore trait in chio-kernel owns the runtime interface for capability budget state and invocation holds. Storage selection determines whether that state survives a process restart. Follow Budgets & Metering for the request lifecycle and Durability for persistence boundaries.

Schema identifiers

Versioned artifact schemas let verifiers select the contract they understand. These credit-report constants identify distinct record types; inspect each type's validator for its accepted schema and required fields.

pub const EXPOSURE_LEDGER_SCHEMA: &str = "chio.credit.exposure-ledger.v1";
pub const CREDIT_SCORECARD_SCHEMA: &str = "chio.credit.scorecard.v1";
pub const CREDIT_FACILITY_REPORT_SCHEMA: &str = "chio.credit.facility-report.v1";
pub const CREDIT_BOND_REPORT_SCHEMA: &str = "chio.credit.bond-report.v1";
pub const CAPITAL_BOOK_REPORT_SCHEMA: &str = "chio.credit.capital-book.v1";

pub const TOOL_MANIFEST_SCHEMA: &str = "chio.manifest.v1";

Pages by task

• Publish a tool: Manifests, Pricing, and Discovery.
• Buy scoped access: Passports and Open Market.
• Evaluate risk and capital: Underwriting, Credit Facilities, and Liability Market.
• Operate across organizations: Two-Org Worked Example and Operating.
• Follow one transaction: How a Purchase Works.