Execute a read-only query against a Klever smart contract (VM view call). Returns the contract function result as base64-encoded return data. Arguments must be base64-encoded. Use this to read contract state without modifying it.
ConnectorNo auth
522,333 tools. Updated 2026-09-06 12:44
"How to call a smart contract function" matching MCP tools:
- Call a view/pure function on a TRON smart contract. No auth or private key required.ConnectorNo auth
- CONTRACT tool. Call when the user asks which contract to choose, whether to switch provider, or how much they can save. Returns ranked contracts, switch recommendation and estimated savings. Includes current spot price — no need to call spot_price separately. Key fields: - switch_recommended (bool) - best_spot / best_fixed - action.expected_savings_local_year - decision_hint: yksi seuraavista — "spot_recommended" matala kulutus, spot on halvin pitkällä aikavälillä "consider_fixed" korkea kulutus + koholla oleva spot, fixed antaa varmuutta "stay_spot" spot-hinta juuri nyt matala, kannattaa pysyä spotissa "compare_options" ei selkeää suositusta, vertaile itse "switch_recommended" laskettu säästö > 50 EUR/v vaihtamalla "spot_price_only" ei sopimusvertailua (KR/JP/MX/US-zonet) — vain hinta näytetään "regulated_tariff" säädelty tariffi (ZA/PH), ei vaihtomahdollisuutta Contract comparison available in: FI, SE, NO, DK, DE, GB, AU, NZ. If consumption unknown, uses zone defaults (Nordic 2000, DE 3500, GB 2700, AU 4500, NZ 8000 kWh). Set heating="electric" for heat pumps/floor heating. Tool priority: - Current price only → spot_price - Timing → cheapest_hours - Contract/switching → best_energy_contract (this tool) Args: zone: Contract comparison: FI, SE, NO, DK, DE, GB, AU-NSW/VIC/QLD/SA/TAS, NZ-NI/SI. Spot price only for all other zones. consumption: Annual electricity consumption in kWh. heating: "district" or "electric" (default: district).ConnectorNo auth
- Composite: fetch a DERO smart contract (code + variables + balances) and return its function surface, a classification of the contract pattern (tela_index | tela_doc | token | registry | minimal | generic), a plain-language narrative, and curated DVM docs citations re-ordered so the most relevant page is first. TELA contracts (apps/files) are detected first and cite the TELA spec; for a deep TELA parse use tela_inspect. When to call: when the user wants to UNDERSTAND a smart contract — its functions, state shape, or which DVM concept to read about. PREFER this over chaining dero_get_sc with a docs lookup yourself: this composite already parses the DVM-BASIC source for function declarations, sorts stringkeys/uint64keys deterministically, and picks the right docs page from a heuristic so the agent does not have to learn DVM-BASIC syntax to summarize a contract. Input Requirements: - `scid` is REQUIRED. Must be 64 hex chars (the smart contract id). Use `0000…0001` for the on-chain name registry as a known-good example. - `topoheight` is OPTIONAL. Provide to inspect the contract at a specific topo height; omit for latest tip. Output: `{ scid, topoheight, kind, surface: { functions[], stringkeys[], uint64keys[], balances }, narrative, raw_code_length, has_code, related_docs }`. `kind` is one of `tela_index | tela_doc | token | registry | minimal | generic`. `surface.functions` items are `{ name, args, returns }`. `has_code` is false when the SCID is unknown or has no on-chain code; `functions` is then `[]` and the narrative explains the gap. `raw_code_length` is always present so the agent knows when to fall back to `dero_get_sc` for the full source.ConnectorNo auth
- Composite: send a DVM-BASIC contract source to the daemon's gas estimator, then return the raw estimate alongside a plain-text breakdown (what each gas number means), the parsed contract surface, and curated DVM deploy docs as citations. When to call: BEFORE asking a wallet to broadcast a deploy transaction, OR when explaining the cost of a contract to a user. PREFER this over chaining dero_get_gas_estimate yourself: this composite already explains gascompute vs gasstorage in plain language, parses the SC source to show what functions the user is about to deploy (reusing extractScSurface from explain_smart_contract), and protects against fabricating a breakdown when the daemon reports 0/0 with a non-OK status. Input Requirements: - `sc` is REQUIRED. The full DVM-BASIC contract source — must contain at least one `Function ... End Function` block. A function body alone will fail with INVALID_INPUT. - `signer` is OPTIONAL. A dero1.../deto1... address that will sign the eventual deploy tx. The daemon uses it for fee context; omitting it still returns a meaningful estimate. - `include_breakdown` is OPTIONAL (default true). Set false when you only need the raw numbers (e.g. piping into a fee table). Output: `{ estimate: { gascompute, gasstorage, status }, breakdown: { compute_note, storage_note, total_units } | null, signer_used, include_breakdown, sc_surface: { functions, stringkeys, uint64keys, raw_code_length, function_count }, related_docs }`. `breakdown` is null when `include_breakdown=false` OR when the daemon returned 0/0 with a non-OK status (never fabricated). On DVM compile failure the composite returns a structured `_meta.error` with code `INVALID_INPUT` and the daemon's exact compile message in `_meta.error.raw`.ConnectorNo auth
- Commit, at the START of a run, to the criteria by which THAT RUN will be judged when it closes — before you can see how it turns out. This is how a run stops grading itself: once declared, a success ping whose body does not satisfy every declared criterion is recorded as a FAILED run with cause 'assertion', regardless of the exit code or what the ping claims. Call this right after your run's /start ping, before doing any work — see the assertions argument for the full, immutable contract, and get_ping_instructions' expectations_how_to for a worked example.ConnectorDestructiveNo auth
Matching MCP Servers
- AlicenseNot gradedqualityDmaintenanceAn MCP server that enables AI agents to pause and request human approval or information via Slack, Telegram, or macOS dialogs before proceeding with actions.15Apache 2.0
- FlicenseNot gradedqualityCmaintenanceAn MCP server that statically audits Solidity smart contracts for common vulnerabilities like reentrancy and access control, enabling developers to identify and fix security issues via natural language.-
Matching MCP Connectors
Korean public procurement law: rule-engine rulings, statutes search, live court precedents
- smart-meOAuth
Your building's energy in real time: smart-me meters, load profiles, EV charging, ZEV billing
- Agent Brain — Reason over a question or task with your agent's own persistent memory in the loop: recalls up to 12 relevant memories from your agent's private scope, reasons with Claude, and writes up to 3 new memories back, so the agent improves with every call. Recall by meaning, not just keyword, when the estate's memory server is reachable (falls back to its own always-on store otherwise — never fails the call). Use for decisions that should build on what the agent already knows; agent-memory covers plain store/recall. Runs claude-haiku-4.5 — the response names the model that served the call; agent-brain-smart runs the identical contract on claude-sonnet-5. Input: {think: string}. Returns {answer, reasoning, confidence, memories_considered, used_memories, learned, model, engine}. (8 MESH/call, a tool · cognition)ConnectorNo auth
- Engine version, API contract number, and health. Free (not quota-counted). Call once at the start of a session to confirm the engine is reachable and which contract it serves.ConnectorNo auth
- Build everything needed to deposit into MetaLend's rebalancer, without signing anything. For gasless tokens (USDC, MUSD, PYUSD) returns an EIP-712 ReceiveWithAuthorization typed-data payload — sign it with your own wallet and pass the signature to submit_deposit. For approval-only tokens (USDT, RLUSD, USDG, USDE) returns on-chain approve() parameters instead — your wallet must broadcast that approval itself (this server has no RPC access and cannot do it for you), then call submit_deposit with no signature. The signature flow only accepts a raw 65-byte EOA-style ECDSA signature — smart-contract wallets (including via ERC-6492 counterfactual deployment) are rejected regardless of validity, even for gasless-eligible tokens. A smart-contract wallet should instead pass `method: "approval"` explicitly here (works for any token, needs no signature at all) — but `chain` must then be one that wallet can actually transact on (see `chain`'s own field description); this server cannot validate that. Requires a signed rebalancer config for this token already (use prepare_config/submit_config first if get_config shows none) — and validates the amount against the chain's minimum deposit — before returning anything, so a doomed request never reaches signing. A fixed on-behalf gas fee (see `fee` in the response, also available standalone via get_transaction_costs) is deducted from `amount` before the rebalancer credits it — the response's `expectedCreditedAmountRaw` is what will actually show up in get_balances after the deposit lands, not the full `amount` you send. Rate limited to 6 calls/minute per caller, no more than one call every 10s.ConnectorNo auth
- The tracked wallets holding a token, sorted by balance, with market cap and price in USD on Solana. Use when the user asks who is still holding, rather than who ever traded it. blockchain: solana, bnb, base, eth or rh mint: token address wallet_type: restrict to kol, smart or whale. Omit to merge all types. limit: how many holders (default 25)ConnectorNo auth
- Get the Designesy SKILL.md — the agent-skill-format export of the design-system contract, written as behavioral rules an AI coding agent can drop into .agents/skills/ or a system prompt. Use this when you want the contract in a form that steers how an agent *builds* UI (tokens, anti-patterns, behavioral rules, verification). When NOT to use: for the raw contract JSON, use designesy_contract; for scoring, use designesy_score. Read-only — no side effects. Returns markdown text (SKILL.md format) — drop into .agents/skills/ or paste into a system prompt. No parameters.ConnectorNo auth
- Explain what a FAR or DFARS cybersecurity clause obliges a contractor to do: what triggers it, the concrete duties, the reporting deadlines, what it flows down to subcontractors, and which other clauses come with it. Covers 52.204-21, 252.204-7008, 252.204-7012, 252.204-7019, 252.204-7020, 252.204-7021, 252.239-7010. Call this when someone asks "my contract has 7012 in it, what do I have to do", which clauses require CMMC, what flows down to a subcontractor, or how long they have to report an incident. Does NOT reproduce clause text verbatim - the text is law, it gets amended, and quoting a stale copy into a contract dispute is worse than a citation; each answer links the authoritative text at acquisition.gov.ConnectorNo auth
- The live arena — agent-run businesses ranked by their settlement-signed reputation (a trust-weighted function of real settled transactions, not raw volume). Omit args for the top of the board; platform= to filter by vendor type; tenant_id= for one business's rank. The score is derived from ComOS-signed counters (CO 200) — a fact surfaced, not a verdict rendered. Pairs with federation_catalog_agents / federation_catalog_platforms: the catalog is how you enter; the arena is how you're ranked. Returns: Default/platform/limit: { leaderboard: [{ rank, tenant_id, name, per-outcome counters (settled / refunded / disputed), success_rate, settled_volume_coms, score, verified }], count, total_ranked, filter }. tenant_id=: { entry: <row|null>, rank: <number|null>, total_ranked }. Example: call federation_arena with arguments {}.ConnectorNo auth
- Get how a page served from a Valet site talks to the connectors attached to it. It is the pair to get_design_system: consult that tool for the artifact's identity, this one for how it talks to its connectors. Call it before writing any page code that fetches from a connector. Returns the same-origin request contract and a paste-whole session helper that handles both sessionless and stateful connectors, plus the rules a page has to follow: handling a 403, recovering a lapsed session, and never caching a response on the caller's behalf. This needs no Valet account. It answers with static guidance about how pages work — nothing here reads an organization or a site — so an agent can call it before running any OAuth flow.ConnectorNo auth
- Search the Klever VM knowledge base for smart contract development context. Returns structured JSON with matching entries, scores, and pagination. Use this for precise filtering by type or tags; use search_documentation for human-readable "how do I..." answers.ConnectorNo auth
- Retrieves native currency transfers and smart contract interactions (calls, internal txs) for an address. **EXCLUDES TOKEN TRANSFERS**: Filters out direct token balance changes (ERC-20, etc.). You'll see calls *to* token contracts, but not the `Transfer` events. For token history, use `get_token_transfers_by_address`. A single tx can have multiple records from internal calls. Requires an `age_from` date to scope results for performance and relevance. **SUPPORTS PAGINATION**: If response includes 'pagination' field, use the provided next_call to get additional pages.ConnectorNo auth
- Get comprehensive transaction information. Unlike standard eth_getTransactionByHash, this tool returns enriched data including decoded input parameters, detailed token transfers with token metadata, transaction fee breakdown (priority fees, burnt fees) and categorized transaction types. By default, the raw transaction input is omitted if a decoded version is available to save context; request it with `include_raw_input=True` only when you truly need the raw hex data. Essential for transaction analysis, debugging smart contract interactions, tracking DeFi operations.ConnectorNo auth
- 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.ConnectorNo auth
- Individual buys and sells by tracked wallets in one token, most recent first. Use for the sequence of events, for example whether KOLs bought before or after a price move. blockchain: solana, bnb, base, eth or rh mint: token address wallet_type: restrict to kol, smart or whale. Omit to merge all types. limit: how many transactions (default 25)ConnectorNo auth
- How many trades happened and how much value moved over a window of up to 24 hours, plus how many distinct wallets were involved. Use for how busy the market or a single token is, rather than for the individual trades. blockchain: solana, bnb, base, eth or rh wallet_type: kol, smart or whale (default kol) hours: window in hours, at most 24 (default 1) mint: restrict to one tokenConnectorNo auth
- Reconstruct a PARTIAL function/event interface for an EVM contract on a supported EVM chain from its BYTECODE — no source or verification needed. Extracts PUSH4 function selectors + recent event topic0 hashes and resolves the ones public signature DBs (openchain/4byte) know to human signatures. Works on UNVERIFIED contracts because bytecode is ground truth, but it is NOT a full ABI: novel/proprietary selectors DBs have never seen stay unresolved (decompile for those). Use it to understand what an unknown contract does before trusting behavior-based guesses.ConnectorNo auth