Skip to main content
Glama
790,399 tools. Updated 2026-11-16 06:24

"Information about XRPL (XRP Ledger)" matching MCP tools:

  • XRPL network overview: XRP price, ledger stats, reserve requirements, base fee
    ConnectorNo auth
  • Historical Benchmarks — the bitemporal benchmark-observations ledger behind the Chip Cost Calculator: wafer cost by node/foundry (deflationary curves), defect-density (D0) learning curves per node, advanced-packaging costs incl. the broken-out CoWoS interposer entity, test cost, backend yield, and HBM $/GB. Each observation carries as_of (the date the reading reflects — curated backfill from dated public archives extends history), detected_at (capture time), and full sourcing metadata (source_type taxonomy: foundry_ir | wfe_vendor_earnings | government_filing | press_release | analyst_report | company_announcement | trade_press | public_web; source_url; confidence high/medium/low). grain=month|quarter returns median/min/max rollups per period; grain=raw returns per-source observations. Access tiers: free key → preview, Pro/Enterprise → full ledger, anonymous → none. USE THIS for: "how has TSMC N5 wafer pricing moved over 24 months?", "is our internal D0 ramp tracking the market's learning curve?", "CoWoS interposer cost trend", benchmarking product-lifecycle cost projections. DO NOT USE for: current point values (use get_wafer_pricing / get_packaging_costs); the daily PIT ledger replay (use /api/v1/snapshot-series); margin history (use /api/v1/margin-trends). Filters: benchmark_type (required: wafer_cost|defect_density|packaging_cost|interposer_cost|test_cost|backend_yield|hbm_cost_per_gb), entity_id, foundry, from/to (as_of bounds), grain (raw|month|quarter), limit. Access: a free API key returns a short preview (latest few observations); Pro/Enterprise unlock the full ledger; anonymous callers get none (empty + a get-a-key note). Cite as "Silicon Analysts — Historical Benchmarks".
    ConnectorNo auth
  • Read the authenticated company's authoritative prepaid credit balance, reserved credits and recent credit-ledger entries. Takes no arguments: the company comes from the connection, not caller input. Use before submitting work to check funds; this does not top up or start a payment. Use skavio_budgets for monthly company/key ceilings, skavio_adapter_usage for this MCP adapter's lifetime ceiling, and skavio_payment_history for cash payment records. Credit-ledger entries are not proof of a card or blockchain payment.
    ConnectorOAuth
  • Retrieve The Hill Kinabalu’s official public wedding venue and 2026/2027 package information, including capacity, event sizes, starting package prices, key inclusions, add-ons without prices, payment structures, and enquiry links. Use this when someone asks about weddings, wedding packages, the event venue, guest capacity, package pricing, or how to enquire. This tool does not check date availability or submit an enquiry.
    ConnectorNo auth
  • Return a filtered slice of the resolved-pick ledger by tier, league, and result. Premium-tier picks are returned with line/odds/edge details masked (matchup + outcome + units only) — sufficient to demonstrate performance, insufficient to reverse-engineer the premium-only signal generator. Args: league: Optional league filter. tier: ``free`` for fully-public picks, ``premium`` for masked subscriber picks. result: WIN, LOSS, or PUSH. limit: Maximum rows (capped at 200). cursor: Zero-based result offset. Prefer get_track_record for new clients. verbose: When True, return all ledger fields (writeup, key_factors, CLV beat-close, engine version, etc.). Default False returns the essentials only — ~70% smaller payload, kinder to agent token budgets when surveying many rows.
    ConnectorNo auth

Matching MCP Servers

Matching MCP Connectors

  • Escrow for AI agents on the XRP Ledger. 51 tools. Free testnet sandbox (no real XRP).

  • About Bureau, the self-hosted office for AI agents: overview, FAQ search, roadmap, install.

  • Create an XRPL escrow vault. Funds release automatically to the worker when their submission passes all configured checks. Free to try: pass network='testnet' (see create_testnet_wallet / try_testnet_demo). Buyers can require NFT ownership, an atomic NFT Delivery-vs-Payment swap, domain verification, or W3C Verifiable Credentials before a PASS releases escrow — set the relevant proof-gate params below. Three release modes: - AI audit (default): worker submits text/files; AI referee scores against task_description or criteria. - Proof-gate only (require_ai_audit=False): payment releases when all configured proof gates pass. No AI call. - Delayed release (release_mode='challenge_window_hrs:N'): PASS holds for N hours then auto-releases. During the window, the buyer can challenge via prepare_challenge_escrow + challenge_escrow_verdict. Challenge fee ~$1 USD in XRP locked to the seller; paid to seller if PASS upheld, refundable if overturned or inconclusive. Structured criteria (recommended for complex work): - Pass criteria as a list of strings or typed dicts ({type, description, [gate]}). - Types: 'judgment' (AI decides), 'evidence' (verify URL content), 'code' (deterministic gate; supported gates: sha256_of, exact_match, regex, json_schema). - INCONCLUSIVE verdicts do not consume an attempt for the first 3 per vault; subsequent INCONCLUSIVEs count as an attempt. White-label / headless integration: - Pass callback_url to receive webhook POSTs on all state changes. - Pass metadata (JSON string) to attach your own reference IDs.
    Connector
    Destructive
    No auth
  • Combines public company, compliance and optional VAT/IBAN consistency checks into a supplier review result. Use when: Review a French supplier before onboarding or payment. You need a compact pre-onboarding or pre-payment review of a French supplier using public company/compliance data plus optional VAT and IBAN checks. You want one normalized supplier verdict while retaining the individual check results. Avoid when: You need a broader multi-section company dossier; use company/fr/intelligence. You only need to compare invoice identifiers and VAT information; use company/fr/invoice-check. Limitations: IBAN validation is structural and does not prove bank-account ownership by the supplier. The result is public-data decision support, not a guarantee that a supplier or payment is fraud-free. Price: 0.050 USD per call via x402. Paid-call behavior: source records are not modified, but a successful invocation can consume the advertised x402 payment; the payment-required challenge is free, and repeating the tool after a completed paid invocation may require a new payment. Accepted x402 networks: eip155:8453, xrpl:0.
    ConnectorNo auth
  • Lists classified events the rules engine could not confidently categorise (needs_review = true, not yet synced to the ledger), newest first. The pipeline is PAUSED for each of these until someone approves a category — they are missing from P&L reports and the ledger. Every item carries what an approver needs to decide without further queries: the source system, event type, amount in cents, currency, direction (inbound = money in, outbound = money out), when it occurred, the counterparty, the category the classifier suggested, and flagged_reason explaining why it was flagged. Resolve an item by calling approve_classification with its classified_event_id and the correct category. Paginate via next_cursor; total_count is the full queue size.
    ConnectorOAuth
  • Create a throwaway sandbox wallet for this client. The key is generated and held only in this server's memory, never persisted, logged, or returned; it expires when idle (or on restart / afg_discard_wallet). Returns a wallet_handle and address to use with the other tools. Refused unless the API confirms a test-money mock ledger. Prefer your own wallet (afg_prepare_signed_request) if you have one. TEST MONEY ONLY: mock ledger, test tokens (tUSDC), no real funds.
    ConnectorNo auth
  • Fetch the public proof payload for one ledger event by its 64-char hex event_hash. When to use: after log_decision/log_outcome when you need trust labels, chain validity, anchor status, or a paired-event proof URL. When NOT to use: to browse many decisions or outcomes — use list_agent_decisions / list_agent_outcomes first, then call get_proof on a chosen event_hash; do not use this to write events (use log_decision / log_outcome). Requires X-API-Key. Returns proof fields only for events in that key's org; unknown or other-org hashes return EVENT_NOT_FOUND (same message either way). Read-only; does not mutate the ledger. Response includes event_hash, event_type, event_seq, public_* mirrors, hash_valid, agent_chain_valid, trust_level, trust_label, proof_anchor_status_label, and chain metadata.
    ConnectorNo auth
  • Check QRIS top-up order payment status (PENDING or PAID), current workspace credit balance, credit mutation ledger history, and official downloadable PDF invoice URLs. Use this tool to verify whether an order from create_qris_invoice has settled or to audit credit consumption; do not use it to generate a new payment invoice (use create_qris_invoice instead) or view campaign click rates (use get_campaign_analytics instead). Read-only operation requiring PUSHNOTIF_API_KEY with 0 credit cost; pass order_id to inspect a single invoice or omit it to list recent orders and ledger entries. Returns JSON { credits_balance, orders: [{ id, amount_rp, credits_added, status, invoice_pdf_url, created_at }], recent_ledger: [{ id, delta, reason, created_at }] }.
    ConnectorNo auth
  • Use only to reverse a bridge_reshape run (from its ledger); every write tool has its own undo. Undoes a bridge_reshape run from the ledger with the plugin's own Undo: every row the run overwrote is written back and every row it created is removed, so the model returns exactly. Refuses on a different model, or when the model was edited since the apply (force: true undoes anyway, overwriting those edits). Resumable: a step that fails is reported and calling again retries only what is left. Default run: the latest not undone. Previews unless apply: true; on the website the apply runs as a background job.
    Connector
    Destructive
    No auth
  • List this account's most recent credit ledger movements (top-ups, calls, SMS, agent usage, monthly number fees, refunds, manual adjustments, and on an account with a monthly plan subscription_grant and subscription_expire), newest first. amountHal is negative for a charge and positive for a credit; a charge covered by the monthly plan credit also carries fromSubscriptionHal. No cursor - just limit; for a specific paid document use list_billing_documents instead. Same data as GET /v1/credit/ledger (response schema in /openapi.json).
    ConnectorAPI key
  • Convenience tool: generate a new XRPL keypair and return the seed. ⚠ NOT RECOMMENDED FOR PRODUCTION. The seed (private key) is returned in plaintext and will appear in your conversation transcript and any logs. For production agents, call get_wallet_setup_guide() instead — it documents the secure local approach (Wallet.generate() + seed in .env) where the seed never leaves your environment. Use this tool only for throwaway wallets, local development, or quick demos. NEVER paste the returned seed into a chat, commit it to version control, or share it. The wallet is NOT yet active on the ledger — fund it before use. XRPL requires 1 XRP minimum to activate a wallet (base reserve). Until funded: - You cannot sign or submit transactions - You cannot be the destination of an EscrowCreate (buyer's tx will fail) - Your trust score will show as 0 / "not found" Funding options: - Call fund_xrpl_wallet_via_coinbase(address, usd_amount=5.0) if you have USDC on Coinbase - Ask your operator or client to send ≥ 1 XRP to the address - Buy XRP on any exchange (Coinbase, Kraken, Binance) and withdraw to the address
    ConnectorNo auth
  • Returns the recommended production wallet setup for XRPL agents. Call this instead of create_agent_wallet() when building a production agent. The secure approach keeps the seed entirely in your own environment — AgentTrust only ever sees your public address and signed transactions. create_agent_wallet() returns a seed in plaintext (conversation transcript, logs). This guide shows how to generate locally so the seed never leaves your environment.
    ConnectorNo auth
  • Use this when you need to confirm or override the open facts in an assumption ledger from trace_from_image (missing scale, inferred/assumed values) before committing geometry built from a reference photo. Reads the persisted `<model>.ledger.json` at `ledgerPath`, applies each resolution — `{ id, confirm: true }` to accept a fact as-is, or `{ id, value }` to override it — rewrites the ledger file, and returns the updated ledger plus `paramOverrides` (factId -> value) to feed straight into `set_param`. Pair with the `kernelcad-from-reference` skill.
    ConnectorNo auth
  • ADDRESS FLOW SUMMARY / top counterparties: who an XRP Ledger (xrp, XRP, ripple, XRPL) account pays and who pays it, in one call — profile (payments sent / received, distinct receivers / senders, tagged incoming payments) + TOP receivers AND TOP senders (ranked by number of payments then Σ amount). NOT only the statistics, without counterparties → use xrp_address_profile. Collapses address_profile + trace_next_hop(out) + an incoming convergence into a single call — call this FIRST when triaging a hop. Returns a computed Role over the same window and currencies as the profile counts (the last `days`, all currencies): receive_only (no outgoing payment in the window) / send_only (no incoming one) / no_transfers (neither) / hub (thousands of senders AND receivers — don't trace deeper) / consolidator (senders ≫ receivers) / distributor (receivers ≫ senders) / relay (neither dominates). An account paid mostly with destination tags (Tagged_Payments_Received close to Payments_Received) is a shared deposit account — an exchange or custodian — whatever its Role. Profile counts are all-currency; the top arrays honor currency, currency_id, issuer, min_amount and max_amount. The arrays carry NO labels: pass Address and the Top_Receivers / Top_Senders counterparties to labels_for_addresses(chain='ripple') in ONE call — it knows the reserve and proof-of-reserves accounts of the large exchanges (Binance's among them); coverage is otherwise sparse, so an empty answer is a coverage gap, not a clean account. For raw rows use xrp_transfers_in / xrp_transfers_out. READING THE TOP ARRAYS: positional 6-tuples [counterparty, amount, currency, currency_id, payments, tagged_payments] (the Top_Fields column lists these names in the same order), one entry per (counterparty, currency) — the same address repeats once per currency it moved. tagged_payments > 0 on a receiver = you paid a shared deposit account (exchange) with destination tags. ONLY PAYMENTS between two different accounts are counted; value moved by an account deletion, check, escrow, payment channel, AMM or NFT sale has no recorded counterparty and is not in the arrays (see Type=other in xrp_transfers_in / xrp_transfers_out). Failed transactions never count. CURRENCY: native XRP is currency_id 413663; any other currency_id is a currency CODE that look-alike issuers reuse — pin the real token with currency_id plus issuer (receivers: the token this account sent; senders: the token this account received). Amounts here are TOKEN UNITS, never USD - no USD value is available in this data, so there is no usd filter and totals for different currencies must not be compared or added together. For a ranking you can reason about, pin ONE currency with currency_id, or bound the range with min_amount / max_amount. Counts and rankings cover the LAST 90 DAYS by default, not the account's whole lifetime; raise days for a longer period. Window_Days / Window_From on the row state the period actually covered: an account busy long ago but quiet since comes back all zeros - raise days. For the full labelled list in USD, totals by label type, or a set of addresses → counterparties.
    ConnectorOAuth
  • MONEYFLOW GRAPH EDGES out of an XRP Ledger (xrp, XRP, ripple, XRPL) account: Source → Target, total Amount, Currency, Currency_Id, payment count and how many of them carried a destination tag. NOT choosing which counterparty to follow next → use xrp_trace_next_hop. Building block for a MoneyFlow DIAGRAM — call per address/hop, collect edges, render Mermaid `graph LR`, flag & stop at exchange / service nodes (the edges carry no labels — identify targets with labels_for_addresses(chain='ripple') in one call; a target receiving tagged payments is a shared deposit account, typically an exchange). Edges are ranked by number of payments then amount. Pin a currency with currency_id to avoid dust and spam tokens; time-window the edges with after_time / before_time. An edge carries the currency that LEFT the source: a cross-currency payment shows only the sent side (what the target received is in xrp_transfers_in of the target), and a conversion into another currency inside one account (a payment to itself) is not an edge at all — to spot an off-ramp, call WITHOUT a currency filter and compare the currencies of consecutive hops. For raw rows use xrp_transfers_out. ONLY PAYMENTS between two different accounts form edges. Value moved by an account deletion, check, escrow, payment channel, AMM or NFT sale has no recorded target on its sending leg, so it is NOT an edge here — open such transactions (Type=other in xrp_transfers_out) with xrp_tx_transfers (an escrow or payment channel pays out in a later, separate transaction). Failed transactions never count. CURRENCY: native XRP is Currency_Id 413663; any other Currency_Id is a currency CODE that look-alike issuers reuse — pin the real token with currency_id plus issuer (matched on the token that left the source). Amounts here are TOKEN UNITS, never USD - no USD value is available in this data, so there is no usd filter and totals for different currencies must not be compared or added together. For a ranking you can reason about, pin ONE currency with currency_id, or bound the range with min_amount / max_amount. Counts and rankings cover the LAST 90 DAYS by default, not the account's whole lifetime; raise days for a longer period.
    ConnectorOAuth
  • AUTO-WALK the dominant (largest total amount) OUTGOING PAYMENT edge of ONE currency from an XRP Ledger (xrp, XRP, ripple, XRPL) account, hop by hop, up to 5 hops — collapses ~5 manual xrp_trace_next_hop calls into one. Follows native XRP by default (currency_id 413663). Every hop returns Hop*_To (the account that received), Hop*_Edge_Total, Hop*_Transfers and Hop*_Tagged_Transfers (how many of those payments carried a destination tag), plus Hops_Found and Path_Status for the walk itself. Hop*_Edge_Total is NOT the amount that travelled along the path: it is the total of EVERY payment of that currency between that hop's sender and receiver over the whole window (days, counted back from today on every hop), so it can be far larger than the sum you are tracing and the hop totals are not comparable with each other. For one hop's full ranking call xrp_trace_next_hop on the hop's sender. The walk NEVER goes back to an account it has already visited (the seed included), and by default it STOPS at an account that was paid with destination tags: that is a shared deposit account, typically an exchange, and its onward payments are the service's own movements, not the traced funds (Path_Status EXCHANGE_DEPOSIT; stop_at_tagged=0 walks on). READ Path_Status FIRST — NO_MATCH means no outgoing payment of this currency in the window (wrong currency_id, or raise days), PATH_END means the trail really ran out, DEPTH_LIMIT means it may continue past hop 5. The walk carries no labels: pass the hop accounts to labels_for_addresses(chain='ripple') in one call and read down to the first labeled account. ONLY PAYMENTS count: value that left through an account deletion, check, escrow, payment channel, AMM or NFT sale is not followed. currency_id identifies a currency CODE, which look-alike issuers reuse, and the walk does not separate issuers — for an issued token check each hop with xrp_trace_next_hop and its issuer filter; a hop INTO the token's issuer means the tokens were redeemed. Amounts are in the currency's own units (XRP, not drops), never USD. LIMITS: follows only the single biggest edge per hop (misses splits / fan-outs), fixed depth 5. For branching tracing call xrp_trace_next_hop hop by hop and choose the next account yourself (prompt_playbook with playbook=money_flow returns the full procedure). A multi-hop walk over busy accounts can take several seconds; lower days, or raise min_amount to step over dust edges.
    ConnectorOAuth
  • INCOMING XRP Ledger (xrp, XRP, ripple, XRPL) transfers to an r-address — where this account received XRP and issued tokens from, newest first: sender, amount, currency, Destination_Tag, record Type and transaction type per row. Use it to trace the source of funds backwards, and with destination_tag to list the deposits of ONE customer of an exchange account. Page back through older history with cursor: pass the Cursor value of the LAST row of a page — unlike before_time it never skips rows that share a ledger. Same record types and amount rules as xrp_transfers_out; for the aggregated view use xrp_address_flow_summary. AMOUNTS: Amount / Currency is what this account actually received (the delivered amount, never the inflated face value of a partial payment); Sent_Amount / Sent_Currency is what the sender actually spent. They differ on a cross-currency payment, and can also differ on a payment of an issued token (for example by the issuer's transfer fee). XRP is in XRP (not drops). TYPE: payment = a Payment from another account (Sender = this account means a currency conversion); trade = a standing exchange offer of this account was filled; other = one leg of an account deletion, check, escrow release, payment-channel claim, AMM or NFT sale, or path-payment rounding, so Sender is EMPTY here. Rounding remainders of that kind below 0.000001 (floating-point leftovers of token payments and offer fills, no real value; a token issuer receives hundreds of thousands) are hidden unless include_dust=1. For an account deletion, cashed check, AMM or NFT sale the paying leg is a separate record of the same transaction: open the Tx with xrp_tx_transfers to see who paid. An escrow release or payment-channel claim pays out what was locked in an EARLIER transaction, so its payer is not in that transaction. nft_trade / mint / burn = NFTs (Currency is the NFT id). Fees never appear here (the fees an account paid are listed by xrp_transfers_out with include_fees=1), and neither do failed transactions — except a failed (expired) NFT offer acceptance, which still shows its nft_trade record although the NFT did not move; xrp_tx_transfers shows Success. Pass type='payment' for payments only. CURRENCY: native XRP is always Currency_Id 413663; any other currency is an issued token, and its Currency_Id identifies only the CODE — look-alike issuers airdrop counterfeit "RLUSD", "USD" and similar tokens under the same code. Pin the real token with currency_id plus issuer (keeps payments that delivered that issuer's token). USD: Price_Usd is the hourly USD price of Currency at the time of the transfer and Value_Usd = Amount x Price_Usd - for XRP only (Price_Status ok). An issued token has no price here (Price_Status no_price, both columns null): never assume one, a currency code says nothing about the token's value. The newest hour may not be priced yet. Amounts and their filters stay in TOKEN UNITS (there is no usd filter), and amounts of different currencies must not be compared or added together: pin ONE currency with currency_id, or bound the range with min_amount / max_amount. Destination_Tag: "0" = no tag. An account whose incoming payments nearly all carry different tags is a shared (exchange / custodial) deposit account. Rows carry no labels: identify senders with labels_for_addresses(chain='ripple') — coverage is sparse, mostly exchange reserve wallets. Covers the LAST 90 DAYS by default; raise days to reach older history (a short or empty page can just mean the window ended, not that the history did). Records arrive a few minutes after the ledger closes. Returns limit transfers per page (default 20, at most 1000), newest first, plus any records identical in every field to the last one (so a page can exceed limit); a sort='amount' page is a top-N and carries no Cursor. Each row: Time, Sender, Currency, Currency_Id, Amount, Sent_Currency, Sent_Currency_Id, Sent_Amount, Destination_Tag, Type, Tx_Type, Ledger, Tx, Price_Usd, Value_Usd, Price_Status, Cursor.
    ConnectorOAuth