# Realmint

> Agent-native scoring, search and routing for tokenized real-world assets across multi-chain.

- name: io.github.realmint-io/mcp
- version: 1.0.0
- connection class: R0 (autonomous)
- trust: 89/100
- quality: 88/100 (good)
- owner: not claimed
- descriptor: https://api.protogrid.dev/v1/servers/io.github.realmint-io%2Fmcp
- tools: https://api.protogrid.dev/v1/servers/io.github.realmint-io%2Fmcp/tools

**An agent can connect right now, no human step.** Remote endpoint, no authentication, reachable on the last probe.

## Connection (mcpServers)

```json
{
  "mcpServers": {
    "realmint-io": {
      "type": "http",
      "url": "https://mcp.realmint.io/mcp"
    }
  }
}
```


## Trust

- hygiene: 100
- liveness: 98
- freshness: 65
- provenance: 90
- drivers: +repository +namespace-matches-repo +website +reachable +uptime-95% ~updated-152d-ago
- Derived from observable signals (official registry feed and our own credential-free probes); no code audit performed.

## Quality 88/100 (good)

### protocol: 75 (weight 25)

- warn `protocol.modern`: newest supported version is 2025-11-25; 2026-07-28 not supported, older versions are deprecated until 2027-07-28
- n/a `protocol.stateless`: only applies to 2026-07-28 servers
- pass `protocol.transport`: streamable HTTP
- n/a `protocol.list_ttl`: only applies to 2026-07-28 servers

### authorization: n/a (weight 15)

- n/a `auth.prm`, `auth.as_metadata`, `auth.cimd`: no remote uses OAuth
- n/a `auth.secret_in_url`: no templated URL

### tool hygiene: 93 (weight 30)

- pass `tools.descriptions`: every tool has a description
- warn `tools.description_length`: 2 tools have descriptions over 1,024 characters, which crowds the context
- pass `tools.schemas`: every tool has an object input schema
- pass `tools.annotations`: 16 of 16 tools declare readOnlyHint or destructiveHint
- pass `tools.directory_hints`: every tool declares readOnlyHint, destructiveHint, idempotentHint and openWorldHint
- pass `tools.token_cost`: about 2,975 tokens to load every tool
- pass `tools.api_dump`: tools are not a one-to-one API dump

### stability: 100 (weight 15)

- pass `stability.changes`: no tool changes in 30 days
- pass `stability.rug_pull`: no tool changed its meaning under the same name

### dependencies: n/a (weight 15)

- n/a `deps.known_vulns`, `deps.mcp_sdk_version`, `deps.resolvable`: no npm or PyPI package

- tools: 16, about 2,975 tokens to load them all
- tool set hash: ae8ae52efe878ba56337b31c7d8243b5
- badge: [![protogrid quality](https://protogrid.dev/badge/io.github.realmint-io/mcp.svg)](https://protogrid.dev/servers/io.github.realmint-io/mcp)
- Checks run on what our credential-free, read-only probes observe; tools are never called and no code audit is performed.

### Tool changes

_No tool definition changes recorded._

## Remotes

- https://mcp.realmint.io/mcp (streamable-http, auth none, reachable true, uptime30d 0.94736844)

## Packages

_none_

## Tools (16)

- `realmint_buy`: Buy `amount_usdc` of USDC worth of the RWA `asset_id` (e.g. 'paxg').
    **Requires sign-in + a one-time wallet delegation** at
    app.realmint.io/mcp/delegate. Realmint signs server-side via your Privy
    delegation, capped per-trade — no key, no per-trade approval. Your smart
    account must already hold USDC (see realmint_deposit). Moves real funds.
- `realmint_deposit`: Show where to send USDC to fund your buying power. **Requires sign-in.**
    Send USDC on Base to your EVM wallet; it funds your smart account for buys.
- `realmint_get_asset`: 
    Get the full schema for a specific RWA by asset ID.
    Includes issuer details, control capabilities (freeze/mint/burn/blacklist),
    transferability restrictions, redemption mechanics, and legal documents.

    The asset ID is the lowercased ticker (e.g. "xaut", "paxg", "kau", "agri",
    "cgo"). Use `realmint_list_assets` to discover all available IDs — the
    catalog spans ~30 tokens across multiple chains and changes over time.

    Always read `metadata.lifecycle` from the response: a non-null lifecycle
    means the token is migrated/discontinued/abandoned and trading is
    disallowed (score is hard-capped at 49).
    
- `realmint_get_asset_history`: 
    Get the versioned metadata change history for an asset.
    Each entry records what changed (created, updated) and a full schema snapshot.
    Useful for detecting when an issuer changes terms or control parameters.
    
- `realmint_get_price_history`: 
    Time-series price history for an asset.

    Args:
        asset_id: Asset identifier
        days: Lookback in days (1-730, default 30)
        granularity: Optional explicit bucket — "5m" | "1h" | "1d". Omit to
            auto-pick (≤2d → 5m, ≤30d → 1h, else 1d). The server cascades to
            coarser buckets when the requested one is empty for this asset.
    
- `realmint_get_route_support`: 
    List the venues and chains that can route this asset, plus per-venue
    backing/liquidity/social scores and policy flags. Use this to check
    whether a trade is even feasible before quoting — `routing_enabled=false`
    or an empty venue list means the asset can be inspected but not traded
    via Realmint.
    
- `realmint_get_score`: 
    Get the Risk & Rights Score for an asset across six dimensions:
    - backing (0-100): proof of reserves, audit cadence, backing mechanism
    - enforceability (0-100): governing law, issuer verification, legal documents
    - control (0-100): issuer power risk — freeze, mint, burn, blacklist, upgrade
    - exit (0-100): redemption, transferability, KYC/whitelist, settlement, holding periods
    - liquidity (0-100): market data, venue count, evidence docs
    - social (0-100): Twitter activity (recency-weighted; unverified handles
      are penalized below the worst observed tier)
    Also returns a weighted composite (0-100, higher is better). Weights and
    penalty tiers are versioned server-side — see `policy_version` in the
    response.

    Combine with the asset's `metadata.lifecycle` field (from
    `realmint_get_asset`) to detect dead/migrated tokens — those are
    score-capped at 49.

    Suggested thresholds for decision-making:
    - composite ≥ 75: typical case, proceed
    - 55 ≤ composite < 75: elevated friction (gates, missing audits, etc.);
      review the asset's flags before proceeding
    - composite < 55: high risk; abort or require explicit user override
    
- `realmint_list_assets`: 
    List all tokenized real-world assets (RWAs) indexed by Realmint.
    Returns the full schema for each asset including ownership, control,
    transferability, redemption terms, and legal metadata.
    
- `realmint_list_instruments`: 
    List instruments — the real-world things tokens represent: an underlying
    at a specific denomination ("Silver · 1 oz") or a stock ("Apple"). Tokens
    sharing an instrument are interchangeable representations of the same
    thing. Each entry carries its member token ids, the recommended member
    (buyable > priced > score), and the floor price across members — use it to
    pick the best token for an instrument before quoting or buying.
    
- `realmint_list_market`: 
    Market snapshots for indexed RWAs: spot price, 24h change, volume, market
    cap, venue count, and a short price history series. Combine with
    `realmint_get_score` to compare risk against liquidity.

    Args:
        ids: Optional comma-separated asset IDs to filter (e.g. "xaut,paxg").
             Empty = all assets. Assets without fresh market data are omitted
             from the response.
    
- `realmint_logout`: Sign out note: Realmint keeps no signing session — server-side signing is
    your standing Privy **delegation**. To fully revoke it, go to
    app.realmint.io/mcp/delegate. Disconnecting the connector ends this session.
- `realmint_my_wallet`: Show your Realmint wallet (EVM + Solana), smart account, and balances.
    **Requires sign-in.** Read-only; moves no funds.
- `realmint_sell`: Sell `amount` of the RWA `asset_id` you hold, settling USDC back on
    Injective. **Requires sign-in + a one-time wallet delegation** at
    app.realmint.io/mcp/delegate. Realmint signs server-side via your Privy
    delegation — no key, no per-trade approval. Sells positions bought over MCP
    (held in your derived Realmint Wallet). Moves real funds.
- `realmint_whoami`: Return the signed-in user's identity. This tool **requires authentication**
    — calling it triggers the Realmint sign-in (OAuth) if you're not signed in.
    Use it to confirm who you're acting as. Read-only; moves no funds.
- `realmint_withdraw`: Withdraw `amount_usdc` USDC from your Realmint smart account to `recipient`
    (any address). **Requires sign-in + a one-time wallet delegation** at
    app.realmint.io/mcp/delegate. Realmint signs server-side via your Privy
    delegation, capped per-transaction — no key, no per-withdraw approval. Native
    USDC on Injective. Moves real funds.

    `smart_account_address` (advanced/recovery, normally leave empty): sweep from
    a specific smart account you own that a factory rotation left behind. Only an
    SA CREATE2-owned by you is accepted.
- `realmint_x402_buy_challenge`: 
    Get the x402 payment requirements to fund yourself in USDC so you can buy
    RWAs — the agent-native on-ramp. This returns the 402 challenge only; it
    moves no funds.

    To complete funding (two signatures total, the same a human gives), the
    agent then, ENTIRELY CLIENT-SIDE:
      1. Reads `accepts[0]` from the returned body: `payTo` is YOUR Base smart
         account (derived from `owner_eoa`), `maxAmountRequired` the USDC atomic
         amount, `asset` the Base USDC contract, `extra` the EIP-712 domain.
      2. Signs an EIP-3009 `transferWithAuthorization(from=owner_eoa, to=payTo,
         value=maxAmountRequired, ...)` over that domain, base64-encodes the
         x402 PaymentPayload, and re-POSTs to `/v1/route/x402-buy` with it in the
         `X-PAYMENT` header. On settlement the USDC bridges custody-free to your
         Injective smart account.
      3. Buys any RWA from that Injective balance via `POST /v1/route/intent`
         (signing the route as usual). The asset rests in your smart account;
         `send` it elsewhere if you want — exactly like a human user.

    Always verify `payTo` derives from your own `owner_eoa` before signing.

    Args:
        owner_eoa: Your EVM EOA — the payment signer and smart-account owner.
        amount_usdc: USDC to fund yourself with (human units, e.g. 25.0).
        asset_id: Optional RWA you intend to buy, recorded for context.
    
