Use Talero public-safe RPC without touching private operator paths

Scope and boundary

Talero exposes Ethereum-style JSON-RPC plus Talero-specific methods for health, finality, checkpoints, diagnostics, fee planning, transaction tooling, and observer-facing PoS data. On a public edge, that surface is filtered through a public allowlist, privacy policy, safe-mode policy, and rate controls.

The page is written for two audiences at once:

• Consumers of the shared public RPC at rpc.talero.info.
• Operators who want to expose a hardened public edge from a self-hosted Talero fullnode.

Endpoint contract

The public JSON-RPC surface is exposed over POST /rpc. On mainnet and testnet, self-hosted Talero nodes bind RPC to 127.0.0.1:8547 by default. Binding a public interface requires an explicit operator acknowledgement, and a publicly bound RPC automatically enables public-mode restrictions.

For public deployments, Talero does not treat RPC as a trusted operator lane. Public mode, privacy mode, and safe mode are part of the contract that clients must tolerate.

Request model

Send a single JSON object with jsonrpc, id, method, and params. Methods accept either positional arrays or object-style params depending on the method. Talero returns a normal JSON-RPC success object with result or an error object with code and message.

curl -sS -X POST https://rpc.talero.info/rpc \
  -H 'content-type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "eth_chainId",
    "params": []
  }'

When you build client code, assume that public nodes may rate-limit, mask some values, or reject expensive calls that would work on a private trusted node.

Quick examples

Best head height

curl -sS -X POST https://rpc.talero.info/rpc \
  -H 'content-type: application/json' \
  -d '{"jsonrpc":"2.0","id":2,"method":"eth_blockNumber","params":[]}'

Safe-mode status

curl -sS -X POST https://rpc.talero.info/rpc \
  -H 'content-type: application/json' \
  -d '{"jsonrpc":"2.0","id":3,"method":"talero_safeModeStatus","params":{}}'

Finality estimate for a transaction hash

curl -sS -X POST https://rpc.talero.info/rpc \
  -H 'content-type: application/json' \
  -d '{
    "jsonrpc":"2.0",
    "id":4,
    "method":"talero_finalityEstimate",
    "params":{"txHash":"0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}
  }'

Hybrid transaction signing hash

curl -sS -X POST https://rpc.talero.info/rpc \
  -H 'content-type: application/json' \
  -d '{
    "jsonrpc":"2.0",
    "id":5,
    "method":"talero_txSigningHash",
    "params":{
      "from":"0x1111111111111111111111111111111111111111",
      "to":"0x2222222222222222222222222222222222222222",
      "nonce":1,
      "gas_limit":21000,
      "max_fee_per_gas":"1000000000",
      "max_priority_fee_per_gas":"100000000"
    }
  }'

Ethereum-compatible read methods

These methods give Talero an Ethereum-shaped consumer surface for wallets, explorers, bridges, and general EVM tooling. Public edges can still apply privacy masking, method quotas, and safe-mode restrictions.

Talero-specific read methods

These methods expose Talero-native status and compatibility information that does not fit cleanly into the Ethereum namespace. They are often the best first stop when you need network identity, policy state, or operator-facing summaries without private detail.

Fees and execution methods

Public consumers often need fee guidance and read-only execution simulation. These methods are allowed on the public-safe surface, but several of them are considered heavy and can be throttled or denied when the public edge is under stress.

On public edges, eth_getLogs, eth_feeHistory, eth_estimateGas, and other heavy methods are the first places where you should expect visible rate limiting when the service is under load.

Finality and checkpoint methods

Talero exposes public-safe finality helpers that go beyond standard Ethereum semantics. They are designed to help wallets, explorers, and bridges distinguish best head from finalized state and reason about risk without pulling private operator data.

If you need a compact public-safe finality answer for a transaction, start with talero_getFinalityReceiptBundle and fall back to talero_finalityEstimate for higher-level UX.

Transaction tooling methods

Talero publishes helper methods for transaction construction and validation. These are especially useful when you need Talero's hybrid transaction-signing policy without embedding private signing logic into the node documentation.

Submission methods

Talero keeps transaction submission available on the public-safe surface unless a node is operating in read-only mode. This means public builders can broadcast signed transactions without being handed any private operator privilege.

Submission methods are still subject to anti-spam rate limiting and to a node's read-only policy. A public-safe surface can accept broadcasts without being a trusted admin endpoint.

PoS observer methods

Talero also exposes observer-facing PoS and BFT methods that help consumers inspect validator sets, active sets, slashing rules, and BFT runtime status. These are public-safe reads, not validator-control methods.

Mining-role RPC such as talero_getWork, eth_getWork, talero_submitWork, eth_submitWork, and hashrate submission flows are role-conditioned and belong in the miner/pool guide, not in the generic public-safe RPC guide.

Public safety model

Talero layers multiple controls on top of the public JSON-RPC surface. Client integrations should assume these controls are normal, not exceptional.

Public binding and public mode

• On mainnet and testnet, a self-hosted Talero node listens on loopback by default.
• Binding RPC publicly requires explicit operator acknowledgement.
• When a node is publicly bound, Talero forces public-mode method restrictions for non-admin callers.

Privacy policy

• Public privacy mode can mask balances or nonces instead of returning raw values.
• Proof and storage reads can be denied on hardened public deployments.
• talero_getPrivacyConfig is the public-safe way to detect these rules.

Safe mode

• Talero safe mode can reduce public concurrency and timeout budgets.
• It can deny heavy public methods when the network is under stress.
• Public mining RPC can also be restricted under elevated safe-mode levels.

Rate limits and heavy methods

• All public clients pass through a general RPC rate bucket.
• Heavy methods use additional quotas, including per-method limits for eth_feeHistory, eth_getLogs, and eth_estimateGas.
• eth_getLogs requires a valid block selector and uses bounded range/result windows on public edges.

Read-only nodes

• A node can run with transaction submission disabled for untrusted callers.
• In that mode, trusted/private callers may still have different behavior than the public edge.
• Public docs should describe the safe public contract, not private trust tiers.

Related public-safe REST aliases

Talero also exposes REST routes that mirror or summarize parts of the public-safe RPC surface. These aliases inherit public guards such as privacy policy and general rate limiting.

The top-level GET /events SSE stream exists separately from JSON-RPC. It is an event stream, not a stable replacement for method-based RPC, and public deployments may choose to keep it narrow or internal.

Error model

Talero uses conventional JSON-RPC success/error objects on /rpc. The exact code can depend on the method family, but the following cases are the ones public clients should expect most often.

On REST aliases, you should expect the same policy outcomes rendered as HTTP status codes: 400 for invalid params, 403 for denied public policy, 404 for not-found targets, 429 for throttling, and 503 when safe mode temporarily restricts a surface.