Talero Network mainnet docs

Mainnet endpoints

Official Talero endpoints are served over HTTPS. Public services may be rate-limited and monitored.

Quick RPC check

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

Public RPC may enforce rate limits. For production integrations, run your own node and use a private endpoint.

Network scope & guarantees

Talero is a hybrid PoW / PoS EVM network designed for measurable security and operator transparency. These docs focus on protocol behavior, node operations and how TLRO is used inside the ecosystem.

What Talero provides

• A programmable EVM environment for contracts and applications.
• A hybrid consensus model combining economic cost (PoW) and finality design (PoS).
• Operational observability: metrics and health signals from day one.
• Tooling for explorers, indexers and integrations.

What Talero does not guarantee

• No promise of fixed returns or “risk-free yield”.
• No guarantee that parameters (fees, limits, rewards) will never change.
• No protection against insecure contracts or poor key management.

Important: TLRO is a network asset used to secure the protocol and pay for execution. Nothing in these docs should be interpreted as financial advice.

Quickstart

Talero nodes expose a simple HTTP surface for operators and builders, and can be placed behind a reverse proxy. The recommended production pattern is: node listens locally + Nginx terminates TLS.

Node endpoints (default)

• / – basic status payload
• /rpc – JSON-RPC endpoint
• /metrics – Prometheus metrics endpoint
• /events – SSE stream (if enabled)

Verify locally

curl -s http://127.0.0.1:8547/ | head
curl -s http://127.0.0.1:8547/metrics | head

Verify through public HTTPS

curl -s https://rpc.talero.info/metrics | head
curl -s -X POST https://rpc.talero.info/rpc \
  -H 'Content-Type: application/json' \
  -d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}'

For high-traffic workloads: run your own node(s), cache where appropriate, and keep the public edge rate-limited.

Architecture overview

Talero separates execution, consensus/finality and indexing. This keeps the system easier to operate and scale.

Key components

• Execution: EVM-compatible accounts, balances, contracts, gas.
• Consensus: hybrid PoW / PoS securing the chain.
• Node surface: JSON-RPC + metrics + optional live events.
• Indexer: query-optimized storage used by the explorer.
• Explorer: UI powered by indexer REST + selected RPC calls.

Hybrid PoW / PoS consensus

Talero combines Proof-of-Work (economic cost / Sybil resistance) with Proof-of-Stake (incentives and finality design). The hybrid model is intended to strengthen security while keeping participation accessible.

Design goals

• Make attacks economically costly via PoW.
• Provide stronger finality properties via PoS mechanisms.
• Keep the EVM execution environment predictable and familiar.

Important: consensus parameters (difficulty, reward splits, staking rules) are subject to explicit upgrades. Always refer to the latest parameter tables for production decisions.

Operations & observability

Talero nodes are built to be operated with visibility: metrics and health signals are part of the default surface. Operators should monitor availability, latency, resource usage, and chain progress.

Metrics endpoint

curl -s https://rpc.talero.info/metrics | head

Recommended operator checklist

• Monitor block height progression and peer connectivity.
• Track RPC error rates and request latency.
• Set rate limits on public endpoints and protect admin/debug methods.
• Keep logs, alerts and dashboards in place before scaling traffic.

Running a node on a VPS

A VPS is ideal for a persistent node, a private RPC endpoint, or an infrastructure component feeding an indexer. Recommended pattern: node on localhost + Nginx TLS + strict rate limiting.

Expose locally and proxy via Nginx

• Node listens on 127.0.0.1:8547.
• Nginx serves https://rpc.talero.info and proxies /rpc and /metrics.

Do not expose raw node ports publicly without TLS, limits and monitoring.

RPC API

Talero supports an Ethereum-compatible JSON-RPC surface for common tooling, plus Talero-specific methods for network operations. Use the public endpoint for light usage and run your own node for production integrations.

Public endpoint

https://rpc.talero.info/rpc

Ethereum JSON-RPC (common)

Talero-specific methods

Talero nodes may expose additional talero_* JSON-RPC methods for operational or protocol-specific queries. These are documented alongside the node releases.

curl -s -X POST https://rpc.talero.info/rpc \
  -H 'Content-Type: application/json' \
  -d '{"jsonrpc":"2.0","method":"talero_epoch","params":{},"id":42}'

If you expose your own RPC publicly, remove debug/admin methods and enforce strict rate limiting.

Explorer & indexer architecture

The explorer provides a human-friendly view of blocks, transactions and addresses. It reads from an indexer API and may use RPC for selected live queries.

High-level flow

• Node produces blocks and transactions.
• Indexer stores structured data for fast queries.
• Explorer calls the indexer via REST /api/....
• Explorer may query RPC for live checks.

Explorer URL: https://explorer.talero.info

Talero Web Wallet

The Talero Web Wallet is a non-custodial interface for managing TLRO accounts and interacting with the network. Keys stay on the user side.

Scope

• Account visibility: balances and basic activity.
• Transactions: TLRO transfers and contract interactions (as available).
• Integration: direct links to explorer for verification.

Security: never share your seed phrase. Use hardware wallets where possible.

TLRO Faucet

The faucet provides small, rate-limited amounts of TLRO to help users get started.

Constraints

• Per-address and per-IP rate limits.
• Fixed small TLRO amount per request.
• Abuse prevention and monitoring.

The faucet is a convenience service. Availability and limits may change.

Mining pool

The official pool provides a UI, miner stats and payouts. Pool endpoints are separate from the RPC endpoints.

Pool URL: https://pool.talero.info

curl -s https://pool.talero.info/api/pool/stats | head

TLRO tokenomics

TLRO is the native asset of Talero Network. It is used for transaction fees (gas), protocol incentives and security participation.

Key properties

• Ticker: TLRO
• Decimals: 18 (EVM-style)
• Base unit: atoms (smallest fraction)
• Max supply target: 1,000,000,000 TLRO

Fees

• Users pay gas fees in TLRO for transactions and contract execution.
• Fees include base fee + priority tips depending on network conditions.

Disclaimer: Tokenomics are technical parameters and may evolve through explicit upgrades. Nothing here is financial or investment advice.

Glossary

• TLRO: native token of Talero Network.
• RPC: JSON-RPC API used by wallets and tools.
• Indexer: off-chain service providing fast query views for UIs.
• Validator: PoS participant responsible for validation/finality roles.
• EVM: Ethereum Virtual Machine execution environment.

FAQ

Is this documentation stable?

It is maintained alongside Talero releases. When protocol or operational surfaces evolve, the docs are updated accordingly.

Where do I find the latest parameters?

Parameters are documented in the relevant sections and are intended to be auditable via public endpoints and on-chain sources where applicable.

Should I rely on public RPC for production?

For production workloads, run your own node and use private endpoints. Public RPC is best-effort and rate-limited.