# Tavchain Source: https://docs.tavchain.safeney.com/index Learn about the network, build with EVM tools, contribute and explore node operations. Tavchain is a general-purpose, EVM-compatible Layer 1 for smart contracts and applications. Build with Solidity and familiar Ethereum tools on a network shaped by Africa's needs and open to developers worldwide. Start with a wallet transfer, deploy a contract or explore the network. Choose what you want to do. > [card] [Use the testnet](/tavchain/getting-started) > > Add Tavchain to your wallet, get Test TAV and send a transaction. > [card] [Build an application](/tavchain/contracts) > > Deploy a Solidity contract with Remix or the Hardhat starter. > [card] [Learn about Tavchain](/tavchain/about) > > Understand accounts, gas, consensus and the network security model. > [card] [Run a node](/tavchain/operate) > > Choose a native client or Docker installation and follow the network. ## Start on testnet 1. [Connect your wallet](/tavchain/connect). 2. [Get Test TAV](/tavchain/faucet). 3. [Send a transfer](/tavchain/first-transfer). You can use the public network without installing a node. Read the [Tavchain whitepaper](/tavchain/whitepaper) for the platform purpose, architecture, TAV and development direction. ## Network resources [Network settings](/tavchain/network) · [Explorer](https://explorer.tavchain.safeney.com/) · [Faucet](https://faucet.tavchain.safeney.com/) · [Service status](https://status.tavchain.safeney.com/) · [RPC reference](/tavchain/http-api) For documentation corrections and developer feedback, see [Contribute](/tavchain/contribute). > [!NOTE] > > Tavchain Testnet is unaudited, with initial validators under shared administration. Test TAV has no monetary value. Read the [security model](/tavchain/learn/security). # About Tavchain Source: https://docs.tavchain.safeney.com/tavchain/about Learn what Tavchain is, how its EVM-compatible Layer 1 works, and where to start with testnet applications and node operation. Tavchain is a general-purpose, EVM-compatible Layer 1 for smart contracts and applications. It provides a shared foundation for developers to build services that help people, businesses and institutions transact, verify information and collaborate. ## Why Tavchain Tavchain's purpose is to support useful applications shaped by Africa's needs and available to users worldwide. The platform is open to different industries and application ideas, with Solidity and familiar Ethereum tools as the starting point. ## What you can build * Payments and commerce applications, including contract-based escrow and payment rules. * Finance and DeFi applications, including token exchanges and lending contracts. * Tokens, memberships, games and other digital-asset applications. * Document-verification and shared-record applications for businesses and institutions. These are application categories developers can build toward, not a list of services already operated by Tavchain. Each application needs its own implementation and security review. Services involving money, identity or physical assets also need appropriate providers, data and legal arrangements. Use Tavchain Testnet to develop your application with Solidity, Ethereum-style accounts and EVM development tools. Read the [whitepaper](/tavchain/whitepaper) for the platform design, participation model and development direction. ## How Tavchain works The node application derives from Cronos 1.8.1 and uses the Cosmos SDK, CometBFT-family consensus and EVM execution. Applications connect through Ethereum JSON-RPC. Native node tooling uses a separate chain identifier and address representation. ## Use the testnet Tavchain Testnet supports native TAV transfers, Solidity contract deployment and interaction, and ERC-20 development. Use the faucet for valueless Test TAV to pay transaction fees. * [Connect a wallet](/tavchain/connect) and [send a transfer](/tavchain/first-transfer). * [Build and deploy a contract](/tavchain/contracts). * [Run a non-validator full node](/tavchain/operate). The initial validators remain under shared administration. The network uses native TAV staking, delegation and governance; active validator membership depends on bonded stake and the configured set size. See the [security model](/tavchain/learn/security) and [current capabilities](/tavchain/status). # Read live blockchain data with AI Source: https://docs.tavchain.safeney.com/tavchain/ai-chain Connect a local read-only MCP server to Tavchain Testnet to inspect blocks, balances, transaction receipts and contract state from your AI editor. Connect your coding assistant to Tavchain's public RPC through the community `evm-rpc-mcp` reader. It can inspect blockchain data without a wallet, private key or node installation. ## Connect your agent The examples below cover four clients. For another MCP-compatible application or agent framework, use **Other clients** to enter the connection settings manually. Install [uv](https://docs.astral.sh/uv/getting-started/installation/) and make sure `uvx` is available to your client. The setup below requests Python 3.12 and pins the reader and MCP SDK to compatible versions. uv may download Python and packages on first use. > [tab] Codex > > Run this command in your terminal: > > ```bash theme={null} > codex mcp add tavchain-chain -- uvx --python 3.12 --with mcp==1.30.0 --from evm-rpc-mcp==0.1.0 evm-rpc-mcp --rpc-url https://api.testnet.tavchain.safeney.com/ > ``` > > Run `codex mcp list` to check the configuration. > [tab] Claude Code > > Run this command from your project directory: > > ```bash theme={null} > claude mcp add --transport stdio tavchain-chain -- uvx --python 3.12 --with mcp==1.30.0 --from evm-rpc-mcp==0.1.0 evm-rpc-mcp --rpc-url https://api.testnet.tavchain.safeney.com/ > ``` > > Open Claude Code and check the server with `/mcp`. > [tab] Cursor > > Add this entry to `.cursor/mcp.json`, preserving any existing servers: > > ```json theme={null} > { > "mcpServers": { > "tavchain-chain": { > "command": "uvx", > "args": [ > "--python", "3.12", > "--with", "mcp==1.30.0", > "--from", "evm-rpc-mcp==0.1.0", > "evm-rpc-mcp", > "--rpc-url", "https://api.testnet.tavchain.safeney.com/" > ] > } > } > } > ``` > > Enable the server in Cursor's MCP settings. > [tab] VS Code > > Add this entry to `.vscode/mcp.json`, preserving any existing servers: > > ```json theme={null} > { > "servers": { > "tavchain-chain": { > "type": "stdio", > "command": "uvx", > "args": [ > "--python", "3.12", > "--with", "mcp==1.30.0", > "--from", "evm-rpc-mcp==0.1.0", > "evm-rpc-mcp", > "--rpc-url", "https://api.testnet.tavchain.safeney.com/" > ] > } > } > } > ``` > > Start the server and enable its tools in Copilot agent mode. > [tab] Other clients > > In a client that supports local MCP servers, choose **stdio** and enter these settings: > > | Setting | Value | > | - | - | > | Name | `tavchain-chain` | > | Command | `uvx` | > > Arguments, in order: > > ```json theme={null} > [ > "--python", "3.12", > "--with", "mcp==1.30.0", > "--from", "evm-rpc-mcp==0.1.0", > "evm-rpc-mcp", > "--rpc-url", "https://api.testnet.tavchain.safeney.com/" > ] > ``` > > Enter each array item as a separate argument if your client has individual argument fields. If it requires a configuration file, use its documented schema: some clients use `mcpServers`, others use `servers`. Keep existing server entries. > > Enable the server, then use the connection check below. Remote-HTTP-only clients cannot launch this local stdio reader. This launches a local stdio process when your client connects. It is not a hosted MCP URL. The client examples use the same reader configuration; Tavchain's runtime acceptance covers Linux x64 with Python 3.12. > [!NOTE] > > Keep the SDK pin. Reader version 0.1.0 uses the MCP SDK 1.x API and fails to start with SDK 2.x. The commands pin the reader and SDK; other dependencies are resolved by uv. ## Check the connection Ask your assistant: ```text theme={null} Use tavchain-chain to call eth_chain_id first. Continue only if it returns 0xbc3ba (771002). Then read the latest block and show its number and hash. ``` Check the result against [Network information](/tavchain/network). This reader does not enforce an expected chain ID automatically. Try these tasks next: | Task | Prompt | | - | - | | Check a transaction | "Check this transaction hash on Tavchain. Show its receipt status and block number. If the receipt is null, say the result is not yet established." | | Read a balance | "Read this public address's native balance on Tavchain. Show the block number and convert the base units to TAV using 18 decimals." | | Read contract state | "Read this contract on Tavchain with eth\_call using the calldata I provide. Show the block number and raw result." | Replace the transaction hash, public address or contract input in your request with the value you want to inspect. ## What the reader can access The reader exposes 13 tools for network identity, blocks, transactions, receipts, balances, nonces, code, storage, logs, gas price and contract calls. It has no signing or transaction-submission tool. Some tool descriptions use Ethereum's term `wei`. On Tavchain, the base unit is `atav`: **1 TAV = 10^18 atav**. Use an explicit block number when comparing several state queries. A missing receipt is not proof of success, and an error object must not be treated as data. Requests use the [public RPC limits](/tavchain/http-api#usage-limits). Keep log ranges small and back off on HTTP 429. Your AI client and RPC provider receive the queries you send; keep secrets out of prompts and configuration. ## Build your own agent Any agent with an HTTP tool or an EVM library can query Tavchain's [Ethereum JSON-RPC endpoint](/tavchain/http-api) directly. MCP is optional. Start by checking `eth_chainId` returns `0xbc3ba`, then use the documented methods for [balances](/tavchain/api/account), [receipts](/tavchain/api/transaction) and contract calls. If your agent framework has an MCP client, give it the same stdio command and arguments shown under **Other clients**. These connection settings do not grant wallet access or signing authority. ## Troubleshooting * **uvx not found:** install uv and restart your editor so it picks up the updated PATH. * **FastMCP import error:** check that the setup includes `--with mcp==1.30.0`. * **Wrong chain ID:** stop using the results and check the configured RPC URL. * **No result or RPC error:** inspect the returned error and [RPC troubleshooting](/tavchain/troubleshooting). Use [Docs for AI](/tavchain/ai-tools) alongside this reader when you want your assistant to consult Tavchain's guides. The documentation connection searches pages; this connection reads live blockchain data. [Upstream package](https://pypi.org/project/evm-rpc-mcp/) · [Ethereum JSON-RPC](/tavchain/http-api) # Use Tavchain with AI Source: https://docs.tavchain.safeney.com/tavchain/ai-tools Connect your coding assistant to Tavchain documentation, find current network settings and use Markdown pages as context for development. Connect your AI assistant to Tavchain Docs so it can search guides and read pages while you build. You do not need a wallet, API key or running node to access the public documentation. ## Connect your assistant Use the public documentation MCP endpoint: ```text theme={null} https://docs.tavchain.safeney.com/mcp ``` Choose your client, or use **Other clients** for manual configuration in another compatible application or agent framework. Your client must support remote HTTP MCP servers. > [tab] Codex > > Add Tavchain Docs from your terminal: > > ```bash theme={null} > codex mcp add tavchain-docs --url https://docs.tavchain.safeney.com/mcp > ``` > > Run `codex mcp list` to check the configuration. > [tab] Claude Code > > Run this command from your project directory: > > ```bash theme={null} > claude mcp add --transport http tavchain-docs https://docs.tavchain.safeney.com/mcp > ``` > > Open Claude Code and use `/mcp` to check the connection. > [tab] Cursor > > Add this entry to your project's `.cursor/mcp.json`. If the file already contains other servers, keep those entries. > > ```json theme={null} > { > "mcpServers": { > "tavchain-docs": { > "url": "https://docs.tavchain.safeney.com/mcp" > } > } > } > ``` > > Enable the server in Cursor's MCP settings. > [tab] VS Code > > With GitHub Copilot agent mode, add this entry to `.vscode/mcp.json`. Keep any existing servers. > > ```json theme={null} > { > "servers": { > "tavchain-docs": { > "type": "http", > "url": "https://docs.tavchain.safeney.com/mcp" > } > } > } > ``` > > Start the server and enable its documentation tools in the agent's tool picker. > [tab] Other clients > > In a client that supports remote MCP servers, enter: > > | Setting | Value | > | - | - | > | Name | `tavchain-docs` | > | Transport | Streamable HTTP (sometimes labelled HTTP) | > | Server URL | `https://docs.tavchain.safeney.com/mcp` | > | Authentication | None for public documentation | > > Save and enable the connection using your client's instructions. Configuration-file keys differ between clients; keep existing server entries. Use the question below to check that the assistant can search the docs. ## Try a question Ask your assistant: ```text theme={null} Use Tavchain Docs to find the current testnet chain ID and RPC URL. Cite the network information page. Do not connect a wallet or send a transaction. ``` Check that the answer cites [Network information](/tavchain/network) and returns chain ID **771002** and RPC URL `https://api.testnet.tavchain.safeney.com/`. A configured server alone does not confirm that your assistant used it. You can also ask it to: * Find the [Hardhat guide](/tavchain/hardhat) and explain how to compile and test a contract locally. * Read the [installation choices](/tavchain/operate) and explain which package matches your operating system. * Explain how to check a transaction receipt using the [JSON-RPC reference](/tavchain/http-api). ## Use a page as context Use **Copy page** beside a page title, or append `.md` to a documentation URL to read its Markdown version. The page menu also offers AI conversation and editor connection options. For assistants that fetch URLs, start with the [documentation index](https://docs.tavchain.safeney.com/llms.txt). It lists pages so the assistant can retrieve the ones it needs. The [full documentation text](https://docs.tavchain.safeney.com/llms-full.txt) is available when you need broader context. ## Documentation and blockchain access The docs MCP searches published documentation. Its search and page-reading tools do not read live wallet balances, sign transactions or control your wallet. A separate feedback tool can submit documentation feedback when you request it. For live blocks, balances and receipts, [connect the read-only blockchain MCP reader](/tavchain/ai-chain) or use the [Ethereum JSON-RPC API](/tavchain/http-api) through an HTTP-capable tool or EVM library. Transaction signing requires a separate wallet or signer and your authorization. Keep private keys, seed phrases and passwords out of prompts and documentation feedback. Check cited pages and the selected network before following generated instructions. # Read a balance and nonce Source: https://docs.tavchain.safeney.com/tavchain/api/account Read native TAV balances and account nonces, select a block or pending state, and interpret base-unit hexadecimal results safely. Read a Tavchain account's native TAV balance with `eth_getBalance` and its transaction sequence with `eth_getTransactionCount`. ## Parameters Both methods take: 1. An EVM account address: `0x` followed by 40 hexadecimal characters. 2. A block selection, such as `"latest"`, `"pending"` or an explicit hexadecimal block number. Use `"latest"` for confirmed state. Use `"pending"` when asking for an account nonce before preparing a transaction. Concurrent submissions from one account need coordinated nonce handling. ## Balance request The zero address below is a read-only example. Do not send assets to it. ```bash theme={null} set -e curl --fail-with-body --max-time 10 \ https://api.testnet.tavchain.safeney.com/ \ -H 'Content-Type: application/json' \ --data '{"jsonrpc":"2.0","id":1,"method":"eth_getBalance","params":["0x0000000000000000000000000000000000000000","latest"]}' ``` ## Results and units The balance result is a hexadecimal integer in `atav`. **1 TAV = 10^18 atav**. The nonce result is a hexadecimal transaction count, not a token amount. Keep values in integer-safe types. An error or unavailable response is not a zero balance. For reproducible comparisons, use the same explicit block number for all related queries. [Response formats](/tavchain/api/schemas) · [Submit a transaction](/tavchain/api/submit-transaction) · [Token balances](/tavchain/api/reference-token) # Read network identity Source: https://docs.tavchain.safeney.com/tavchain/api/network-selection Identify Tavchain Testnet using eth_chainId, interpret the hexadecimal result and distinguish wallet identity from the native node chain ID. Call `eth_chainId` before using a wallet or client connection to Tavchain Testnet. Its numeric EVM chain ID is **771002**. ## Request `eth_chainId` takes an empty parameter array. ```bash theme={null} set -e curl --fail-with-body --max-time 10 \ https://api.testnet.tavchain.safeney.com/ \ -H 'Content-Type: application/json' \ --data '{"jsonrpc":"2.0","id":1,"method":"eth_chainId","params":[]}' ``` ## Result Expect `result: "0xbc3ba"`, the hexadecimal representation of 771002. Native nodes use `tavchaintestnet_771002-1`; that string is not the wallet chain ID. A matching chain ID helps detect a wrongly selected endpoint. It does not independently authenticate the server. ## Check progress Use `eth_blockNumber` with an empty parameter array to read the current EVM head as a hexadecimal quantity. For a local node, inspect native sync status and peers using [Monitor a node](/tavchain/operate/monitoring). [Network settings](/tavchain/network) · [Response formats](/tavchain/api/schemas) # API overview Source: https://docs.tavchain.safeney.com/tavchain/api/openapi Choose between Tavchain Ethereum JSON-RPC, explorer, faucet and local node interfaces, with links to the appropriate request and response guides. Tavchain exposes several interfaces for different tasks. Choose the interface that corresponds to the information or operation you need. | Interface | Use it for | | - | - | | [Ethereum JSON-RPC](/tavchain/http-api) | Canonical chain queries and locally signed transaction submission. | | [Explorer](https://explorer.tavchain.safeney.com/) | Indexed blocks, transactions, tokens and verified contract source. | | [Faucet](/tavchain/faucet) | Requesting Test TAV through its claim workflow. | | [Local node RPC](/tavchain/operate/network-assets) | Operating and inspecting your own full node. | ## Ethereum JSON-RPC Use HTTP POST with JSON-RPC 2.0 request objects. Start with [network identity](/tavchain/api/network-selection), [account reads](/tavchain/api/account), [transaction submission](/tavchain/api/submit-transaction) and [receipts](/tavchain/api/transaction). The [response-format reference](/tavchain/api/schemas) explains quantity, address and error representations. The endpoint is not described by a Tavchain OpenAPI REST specification. ## Service boundaries Explorer responses are indexed observations and can lag chain data. The faucet is a test-token distribution service, not a server wallet for application transactions. Neither interface requires your wallet private key. The historical custom `/v1` gateway is not the API for the current EVM network. Use the endpoints in [Network information](/tavchain/network). # Read an ERC-20 token balance Source: https://docs.tavchain.safeney.com/tavchain/api/reference-token Query ERC-20 balanceOf and decimals using a token contract, distinguish token balances from native TAV and format raw amounts safely. Read an ERC-20 token balance by calling the deployed token's `balanceOf(address)` method. Use that token's ABI and contract address on Tavchain Testnet. > [!NOTE] > > You can inspect the [verified GLD reference contract](https://explorer.tavchain.safeney.com/address/0x9FEE6A0eAf071Dc6fFa1B6193cE1ab52E085F525?tab=contract) on Tavchain Testnet, chain ID **771002**. It is a valueless demonstration token, separate from native TAV. The [Hardhat guide](/tavchain/hardhat#example-deployment) links its deployment and transfer transactions. ## Choose the asset Confirm the chain ID and token contract address before querying. A symbol such as GLD is not a unique identifier. Native TAV uses `eth_getBalance`; an ERC-20 keeps its own balances in contract state. ## Read in Remix or the explorer 1. Open your deployed ERC-20 in Remix, or open a verified token contract's read interface in the [explorer](https://explorer.tavchain.safeney.com/). 2. Find `balanceOf` and enter the holder's public EVM address. 3. Read the returned integer. 4. Read `decimals()` from that same contract and use it to format the amount. The [ERC-20 tutorial](/tavchain/erc20-token#read-the-supply-and-balance) provides the complete GLD workflow and expected initial supply and balance. For the reference contract, `decimals()` returns `18` and `totalSupply()` returns `1000000000000000000000` (1,000 GLD). Holder balances depend on the queried block; the [reference transfer](/tavchain/hardhat#example-deployment) records a comparison at block 10833. ## Read from an application Use an EVM client library with the token ABI to encode `balanceOf(address)` and perform `eth_call` against the token contract. The call returns ABI-encoded data, which the library decodes to an integer. Use a specific block when you need a reproducible comparison. A read-only call does not submit a transaction or require a wallet signature. Check RPC errors and confirm the contract actually implements the expected interface. ## Decimals Token decimals are independent of native TAV's 18 decimals. For a token with 18 decimals, a raw balance of `1000000000000000000` displays as one token. Keep arithmetic integer-safe. [Create an ERC-20](/tavchain/erc20-token) · [Native balance](/tavchain/api/account) · [RPC reference](/tavchain/http-api) # JSON-RPC response formats Source: https://docs.tavchain.safeney.com/tavchain/api/schemas Interpret Tavchain JSON-RPC results, errors, hexadecimal quantities, addresses, byte data and receipt execution status. Tavchain's Ethereum JSON-RPC endpoint uses JSON-RPC 2.0. Each response identifies the request by `id` and contains either `result` or `error`. ## Successful response ```json theme={null} {"jsonrpc":"2.0","id":1,"result":"0xbc3ba"} ``` ## Field formats | Value | Representation | | - | - | | Balance, nonce, gas or block number | A `0x`-prefixed hexadecimal quantity; zero is `0x0`. | | EVM address | `0x` followed by 40 hexadecimal characters. | | Transaction or block hash | `0x` followed by 64 hexadecimal characters. | | Bytes or calldata | `0x`-prefixed hexadecimal data. | | Receipt not available | JSON `null`. | Use integer-safe parsing for quantities. Native balances use `atav`, with **10^18 atav per TAV**. Contract return data is ABI-encoded and must be decoded according to the contract's ABI. ## Errors and execution status Inspect the JSON-RPC `error` object separately from the HTTP status. HTTP 429, HTTP 503 and connection failures can occur before a JSON-RPC response is returned. Receipt status `0x1` means execution succeeded; `0x0` means execution failed. A successful HTTP request does not imply a successful contract transaction. [RPC limits](/tavchain/http-api) · [Receipts](/tavchain/api/transaction) · [Troubleshooting](/tavchain/troubleshooting) # Submit a signed transaction Source: https://docs.tavchain.safeney.com/tavchain/api/submit-transaction Submit locally signed EVM transaction bytes to Tavchain, interpret the returned hash and handle uncertain broadcast outcomes safely. Submit an already signed EVM transaction to Tavchain with `eth_sendRawTransaction`. Your wallet or local signing library signs for chain ID **771002**; public RPC does not need your private key. ## Parameter Pass one value in `params`: the complete signed transaction bytes as `0x`-prefixed hexadecimal data. ## Request format ```json theme={null} {"jsonrpc":"2.0","id":1,"method":"eth_sendRawTransaction","params":["0xSIGNED_TRANSACTION_BYTES"]} ``` The signed-bytes placeholder is intentionally not executable. Prepare the sender, recipient or contract, amount, nonce, gas and fee settings in your wallet or signing library, then review them before signing. ## Result A successful submission returns the transaction hash. This identifies the transaction for lookup; it does not prove execution succeeded. Query [the receipt](/tavchain/api/transaction) to inspect execution. ## Uncertain submission If the request times out, retain the original hash and check its status before resubmitting. Replacing a transaction is a deliberate nonce and fee decision, not a generic network retry. [Response formats](/tavchain/api/schemas) · [Transaction lifecycle](/tavchain/learn/transactions) # Read a transaction receipt Source: https://docs.tavchain.safeney.com/tavchain/api/transaction Read a Tavchain transaction receipt, distinguish pending or missing results from execution failure, and inspect block and gas information. Use `eth_getTransactionReceipt` to inspect the execution result of a submitted Tavchain transaction. ## Parameter and request Pass the exact transaction hash: `0x` followed by 64 hexadecimal characters. Replace the placeholder in this request with your transaction hash. ```json theme={null} {"jsonrpc":"2.0","id":1,"method":"eth_getTransactionReceipt","params":["0xYOUR_64_HEX_CHARACTER_TRANSACTION_HASH"]} ``` ## Result A `null` result means this endpoint has no receipt at that moment. It does not prove the transaction was never broadcast. A non-null receipt includes transaction and block identifiers, gas usage and an execution status: | `status` | Meaning | | - | - | | `0x1` | Execution succeeded. | | `0x0` | Execution failed; gas can still be charged. | ## Verify a transfer Read `eth_getTransactionByHash` to inspect the recipient and native transfer amount. For exact balance accounting, query the same explicit block. A receipt alone is not a complete payment record. Look up the same hash in [the explorer](https://explorer.tavchain.safeney.com/). Indexing can lag the chain. If an RPC request fails or the outcome is unclear, inspect the existing transaction before submitting a replacement. [Response formats](/tavchain/api/schemas) · [First transfer](/tavchain/first-transfer) # Connect to Tavchain Source: https://docs.tavchain.safeney.com/tavchain/connect Add Tavchain Testnet to an EVM wallet using the chain ID, RPC and explorer settings, then select the network before signing transactions. Open [Add Tavchain Testnet](https://testnet.tavchain.safeney.com/#wallet-heading) in the same browser as your wallet and approve the network request. If your wallet does not support the button, enter the settings below manually. ## Network details | Setting | Tavchain Testnet | | - | - | | Network name | Tavchain Testnet | | RPC endpoint | `https://api.testnet.tavchain.safeney.com/` | | Chain ID | `771002` | | Currency symbol | `TAV` | | Native currency | Tavcoin, 18 decimals | | Block explorer | [explorer.tavchain.safeney.com](https://explorer.tavchain.safeney.com/) | ## Add the network **1. Open your wallet's network settings** Choose **Add a custom network**. Wallet labels vary by version; see [MetaMask's network guide](https://docs.metamask.io/metamask-connect/evm/guides/manage-networks/). **2. Enter the network details** Copy the RPC endpoint, chain ID, currency symbol and explorer URL from the table above. **3. Select Tavchain Testnet** Save the settings and select the network before requesting Test TAV or sending a transaction. Adding a network does not transfer funds or import a key into Tavchain's server. No VPN, node installation or separate Tavchain registration is required for the wallet flow. ## Check the network in your application Select Tavchain Testnet for the connected site in the same browser as your wallet. Check that the application shows chain ID **771002** before signing. For Remix-specific steps, see [Deploy a contract](/tavchain/deploy-token#connect-your-wallet). > [accordion] Using a previous Tavchain testnet? > > The current EVM chain ID is **771002**. Balances, account nonces and contracts from the previous **771001** networks are not carried forward. Select the current network and request fresh Test TAV. ## For application developers > [accordion] Add the network from an application > > With a provider explicitly selected by your user, the common network-add request is: > > ```javascript theme={null} > await provider.request({ > method: "wallet_addEthereumChain", > params: [{ > "chainId": "0xbc3ba", > "chainName": "Tavchain Testnet", > "nativeCurrency": { > "name": "Tavcoin", > "symbol": "TAV", > "decimals": 18 > }, > "rpcUrls": [ > "https://api.testnet.tavchain.safeney.com/" > ], > "blockExplorerUrls": [ > "https://explorer.tavchain.safeney.com/" > ] > }], > }); > ``` > > Ask separately to switch if needed using `wallet_switchEthereumChain` with `chainId: "0xbc3ba"`. Wallets may decline either request. Check `eth_chainId` after selection; adding a network alone does not establish the active chain. Trigger wallet requests from an intentional user action, not page load. Treat this as a standard provider integration example and check behavior with the wallet versions your application supports. > [accordion] Check the chain ID with JSON-RPC > > ```bash theme={null} > curl --fail-with-body --max-time 10 \ > https://api.testnet.tavchain.safeney.com/ \ > -H 'Content-Type: application/json' \ > --data '{"jsonrpc":"2.0","id":1,"method":"eth_chainId","params":[]}' > ``` > > The expected `result` is `"0xbc3ba"`. An unavailable endpoint may return HTTP 503; do not switch to an unrelated chain or paste a private key into a website to work around it. ## Next steps > [card] [Get Test TAV](/tavchain/faucet) > > Request development tokens for transfers and contract execution. > [card] [Send a transfer](/tavchain/first-transfer) > > Make a small transfer and verify the execution result. # EVM contract workflow Source: https://docs.tavchain.safeney.com/tavchain/contracts Choose Remix or Hardhat to compile, test, deploy and verify Solidity contracts on Tavchain Testnet, with links to token and transaction guides. Build Solidity contracts on Tavchain Testnet using familiar Ethereum development tools. Choose a browser workflow for a first contract or a local project for compilation and tests. > [card] [Remix quickstart](/tavchain/write-contract) > > Write and compile Greeter, then deploy and interact with MetaMask. > [card] [Hardhat project](/tavchain/hardhat) > > Build and test locally, deploy with Ignition and verify source. > [card] [ERC-20 token](/tavchain/erc20-token) > > Create an OpenZeppelin token, read balances and transfer tokens. > [card] [Verify source](/tavchain/verify-contract) > > Publish the original source and compiler settings to the explorer. ## Build an application Smart contracts let you define application rules and update shared state on Tavchain. You can use them as building blocks for payments and escrow, finance and DeFi, tokens, memberships, games and verifiable records. These guides demonstrate contract deployment, token transfers and source verification. Broader applications require their own contracts, interfaces, security checks and any necessary external integrations. A smart contract cannot independently verify an off-chain event such as delivery of physical goods. ## Before deploying [Connect to Tavchain Testnet](/tavchain/connect), chain ID **771002**, and obtain [Test TAV](/tavchain/faucet) for gas. Retain your source, dependencies, compiler settings and deployment artifacts for later verification. The tutorials use Solidity **0.8.21**, the **Shanghai** EVM target, optimization enabled and **200 runs**. Use the settings specified by your own project when building or verifying a different contract. ## Reads and transactions Read-only contract calls use `eth_call` and do not submit a transaction. Deployment and state-changing methods require local signing and gas. Check [transaction receipts](/tavchain/api/transaction) after submission. ## Explore a deployed example Inspect either verified example on chain **771002**: * [Greeter reference contract](https://explorer.tavchain.safeney.com/address/0x065c1c017b8EF74f3B6001b51d188665bA9f4cd1?tab=contract), using the [Remix deployment workflow](/tavchain/deploy-token). * [GLD reference contract](https://explorer.tavchain.safeney.com/address/0x9FEE6A0eAf071Dc6fFa1B6193cE1ab52E085F525?tab=contract), using the [Hardhat starter](/tavchain/hardhat#example-deployment), with a successful 10-GLD transfer. Deploy your own instance when following a tutorial. Use [Verify a contract](/tavchain/verify-contract) to publish its original source and compiler settings. ## Compatibility and security General EVM compatibility does not guarantee every opcode revision, precompile or tool combination. Consult [release information](/tavchain/status) and validate your application's requirements. The examples are demonstrations, not audited contracts for valuable assets. # Contribute to Tavchain Source: https://docs.tavchain.safeney.com/tavchain/contribute Improve the docs, share developer feedback and report problems. Contribute to Tavchain by improving the documentation, reporting reproducible issues or examining the published node source. > [card] [Improve the docs](/tavchain/contribute/reporting) > > Report an unclear page, missing step or incorrect example. > [card] [Report a problem](/tavchain/contribute/reporting#report-a-problem) > > Share the expected result, actual result and steps to reproduce it. ## Source and licensing The [node release downloads](/tavchain/operate/network-assets) include application source, dependency sources, build instructions and third-party notices. Tavchain's node-source modifications use Apache 2.0; dependencies retain their own licenses. The [Hardhat starter](/tavchain/hardhat) is available under its included MIT terms and notices. Browse the [Tavchain node repository](https://github.com/safeney/Tavchain) to inspect the source, open a reproducible code issue or propose a pull request. Read the [contribution guidelines](https://github.com/safeney/Tavchain/blob/main/CONTRIBUTING.md) before submitting changes. Source archives remain available with the authenticated releases. ## Get in touch Email [support@safeney.com](mailto:support@safeney.com) with the page URL or affected component and a concise description. Follow the [reporting guide](/tavchain/contribute/reporting) for details to include. Security concerns should be reported privately. No bug bounty or contributor grant program is announced. [Start building](/tavchain/getting-started) · [Security model](/tavchain/learn/security) # Report an issue Source: https://docs.tavchain.safeney.com/tavchain/contribute/reporting What to include in documentation, developer and security reports. Report non-sensitive node-code problems in [GitHub Issues](https://github.com/safeney/Tavchain/issues), or contact [support@safeney.com](mailto:support@safeney.com) for documentation corrections and developer support. Send security concerns privately by email. Include enough information to reproduce the problem without sharing secrets. ## Improve a documentation page Send the page URL, the unclear or incorrect passage and your suggested correction. Include the relevant network and tool version when behavior depends on them. ## Report a problem Include: * What you were trying to do. * The tool or wallet and its version. * The selected network and chain ID. * The expected result, actual result and exact error. * The smallest steps needed to reproduce the issue. * A public transaction hash, if relevant. Check [Troubleshooting](/tavchain/troubleshooting) first. For an uncertain transaction submission, retain the original hash and inspect its receipt before submitting a replacement. ## Report a security concern Email the same address with the subject **Tavchain security report**. Describe the affected component, likely impact and safe reproduction steps. Send the report privately rather than posting sensitive exploitation details publicly. Remove personal data and credentials from logs or screenshots. Do not include seed phrases, private keys, wallet passwords, provider tokens, signer state or unrestricted server access. No bug-bounty payment, safe-harbor terms or guaranteed response time is offered by this page. [Back to Contribute](/tavchain/contribute) · [Security model](/tavchain/learn/security) # Deploy a contract Source: https://docs.tavchain.safeney.com/tavchain/deploy-token Deploy Greeter on Tavchain Testnet with Remix and MetaMask, read its state, send a contract update and inspect the resulting receipt. Deploy the [compiled Greeter](/tavchain/write-contract) to Tavchain Testnet using Remix and MetaMask, then read and change its greeting. > [!NOTE] > > A [verified Greeter example](https://explorer.tavchain.safeney.com/address/0x065c1c017b8EF74f3B6001b51d188665bA9f4cd1?tab=contract) is available on chain **771002**. Deploy your own instance to follow the tutorial from its initial state; the shared example allows anyone to change its greeting. ## Connect your wallet 1. In Remix, open **Deploy & Run Transactions**. 2. Choose **Browser Extension**, then **MetaMask**. Older versions may call this **Injected Provider** or **Injected Web3**. 3. Approve connecting `app.remix.live` in MetaMask. Unlock the wallet privately if needed. 4. With the Remix tab active, select **Tavchain Testnet** for that connected site in MetaMask. Before deploying, require **Custom (771002)** and your intended account in Remix. If Remix shows **Main (1)** or another chain, stop before clicking Deploy. Check MetaMask in the same browser/profile as this Remix tab and switch that site's connected network. Reconnect the wallet if the display has not updated, then check the chain again. Remix's generic balance or fee label may say ETH. On chain **771002**, the native coin is **Test TAV**. Verify the chain ID instead of relying on that label. If MetaMask is missing, open Remix in the same browser/profile where the extension is installed. A wallet available in another browser is not automatically available to this tab. ## Deploy once 1. Select **Greeter** and confirm it is compiled using the [compiler settings](/tavchain/write-contract). 2. Leave **Value** at **0**. This constructor takes no arguments. For the separate verification workflow in this guide, turn off **Verify Contract on Explorers** if Remix displays that switch. 3. Click **Deploy** once. 4. In MetaMask, review Tavchain Testnet, the contract-deployment request and estimated fee. Confirm once. 5. Wait for the successful receipt. Save the transaction hash and the created contract address. If the result is uncertain, check MetaMask activity and [the receipt](/tavchain/api/transaction) before trying again. Repeating deployment creates a different contract and charges another fee. Use the fee displayed by your wallet before confirming. ## Read the greeting Under **Deployed Contracts**, expand your Greeter instance. Next to **greet**, click **Call**. The result should be: ```text theme={null} Hello ``` This is a read-only call and needs no wallet transaction or gas payment. ## Optional: change the greeting 1. Enter `Hello Tavchain` in **setGreeting (string)**. 2. Leave **Value** at **0** and click **Transact** once. 3. Review and confirm that contract interaction in MetaMask. 4. Save the new transaction hash and require a successful receipt. 5. Click **Call** beside **greet** again. It should now return `Hello Tavchain`. The receipt should include a **ChangeGreeting(address,string)** event with your account and the new text. Another user can change this demonstration contract too; it has no access control. Read the receipt for the actual gas used and effective gas price. ## Check the explorer Search your transaction hash in [the explorer](https://explorer.tavchain.safeney.com/). Check success, sender, contract address, block and fee. An indexed deployment does not mean the explorer has verified the contract's source code. The [reference deployment transaction](https://explorer.tavchain.safeney.com/tx/0x5af18cfbcaf540d8b99e800aa8cb388fb99d4dab3198ebf84e204b906d46beff) created Greeter at `0x065c1c017b8EF74f3B6001b51d188665bA9f4cd1` on chain **771002**. Its [Contract → Code page](https://explorer.tavchain.safeney.com/address/0x065c1c017b8EF74f3B6001b51d188665bA9f4cd1?tab=contract) shows **Contract source code verified (exact match)**. Use your own returned address when following the tutorial. The shared example's greeting may have changed since deployment. ## Verify the source Follow [verify a contract](/tavchain/verify-contract) to publish your source and enable the explorer's Read/Write contract interface. Verify your own deployment and require an exact source match. Previous verification results do not transfer across a genesis reset. ## Related guides * [Write and compile Greeter](/tavchain/write-contract) * [Transaction receipts](/tavchain/api/transaction) * [Troubleshooting](/tavchain/troubleshooting) # Create and transfer an ERC-20 token Source: https://docs.tavchain.safeney.com/tavchain/erc20-token Deploy OpenZeppelin's example ERC-20 on Tavchain Testnet, read balances, transfer tokens, and verify the source with standard Ethereum tools. Create an example ERC-20 using OpenZeppelin's implementation, deploy it through Remix and MetaMask, then transfer tokens and check the receipt in Tavchain's explorer. > [!NOTE] > > A [verified GLD reference deployment](/tavchain/hardhat#example-deployment) is available on chain **771002**, built with the Hardhat starter. This guide uses Remix; deploy your own instance and retain its original source and compiler input for verification. This example uses **Gold (GLD)**, the fictional game currency from [OpenZeppelin's ERC-20 guide](https://docs.openzeppelin.com/contracts/5.x/erc20). It is a valueless test token, not gold-backed, native TAV or an official Tavchain asset. Gas fees are paid in Test TAV. ## Before you begin [Connect MetaMask](/tavchain/connect) to Tavchain Testnet, chain ID **771002**, and obtain [Test TAV](/tavchain/faucet). Use a second public address you control for the token transfer. ## Create the contract In [Remix](https://remix.ethereum.org/), create `GLDToken.sol` and paste: ```solidity GLDToken.sol theme={null} // SPDX-License-Identifier: MIT pragma solidity ^0.8.20; import {ERC20} from "@openzeppelin/contracts@5.6.1/token/ERC20/ERC20.sol"; contract GLDToken is ERC20 { constructor(uint256 initialSupply) ERC20("Gold", "GLD") { _mint(msg.sender, initialSupply); } } ``` This follows OpenZeppelin's MIT-licensed example with its dependency pinned to **5.6.1**. The constructor gives the initial supply to the deploying account. No extra minting function or administrator is added. Compile with Solidity **0.8.21+commit.d9974bed**, **Shanghai**, optimization enabled and **200 runs**. Remix resolves the versioned import; retain the source, imported files and original compiler input for verification. ## Deploy 1,000 example tokens ERC-20 amounts are integers in the token's smallest unit. OpenZeppelin's default `decimals()` is **18**, so: | Display amount | Raw contract amount | | - | - | | 1 GLD | `1000000000000000000` | | 10 GLD | `10000000000000000000` | | 1,000 GLD | `1000000000000000000000` | 1. In **Deploy & Run Transactions**, choose **Browser Extension → MetaMask** and confirm the network is **Custom (771002)**. 2. Select **GLDToken**. 3. Enter `1000000000000000000000` for the constructor's `initialSupply`. 4. Leave **Value** at **0**. You are creating tokens, not buying them with TAV. 5. Click **Deploy** once, review the deployment and fee in MetaMask, and confirm. 6. Wait for a successful receipt. Save the contract address and transaction hash. Follow [deploy and interact](/tavchain/deploy-token) for the wallet workflow. If the result is unclear, check wallet activity and the receipt before trying again. ## Read the supply and balance Expand your deployed **GLDToken** in Remix. Read: | Method | Expected result immediately after deployment | | - | - | | `name()` | `Gold` | | `symbol()` | `GLD` | | `decimals()` | `18` | | `totalSupply()` | `1000000000000000000000` | | `balanceOf(your deploying address)` | `1000000000000000000000` | These reads do not require a wallet transaction or gas payment. ## Transfer 10 GLD 1. Expand **transfer**. 2. Enter your second account's public address in `to`. 3. Enter `10000000000000000000` in `value`. 4. Keep Remix's separate transaction **Value** at **0**. 5. Click **Transact** once. Review and confirm the interaction in MetaMask. 6. Wait for a successful receipt and check the **Transfer** event for the sender, recipient and raw amount. If no other transfers occurred and the recipient started with zero GLD, the sender now has **990 GLD**, the recipient **10 GLD**, and total supply remains **1,000 GLD**. Gas reduces the sender's Test TAV balance separately. ## Inspect and verify Search the deployment and transfer hashes in [the explorer](https://explorer.tavchain.safeney.com/). Check the chain, contract address, successful receipt and token-transfer event. Follow [verify a contract](/tavchain/verify-contract) using **Standard JSON input**, including the OpenZeppelin imports and original compiler settings. A source file with unresolved imports is not the complete verification input. Once verified, the explorer exposes the ABI's read/write methods. To display GLD in your wallet, use its custom-token import flow on Tavchain Testnet with your deployed contract address and the token's actual symbol/decimals. Importing a token only changes its display in that wallet. ## Example token Open the [Hardhat GLD reference contract](https://explorer.tavchain.safeney.com/address/0x9FEE6A0eAf071Dc6fFa1B6193cE1ab52E085F525?tab=contract) to inspect its verified source, deployment and transfer transactions on chain **771002**. The [Hardhat guide](/tavchain/hardhat#example-deployment) records its 1,000-GLD initial supply and the balances after a 10-GLD transfer. The reference was built with Hardhat's npm import path. This Remix guide uses a versioned import path, so its compiler input and metadata differ. Deploy your own instance to follow the initial-supply and transfer steps above. Source filenames and compiler settings affect verification metadata. Keep your own original input. This demonstration is not an official Tavchain token or a security audit. ## Continue locally [Use the Hardhat starter](/tavchain/hardhat) for local compilation, contract tests and a disposable Ignition deployment of the same GLD example. Its local npm import path and artifact metadata differ from this Remix build. ## Related guides * [EVM contract workflow](/tavchain/contracts) * [Read an ERC-20 balance](/tavchain/api/reference-token) * [Verify a contract](/tavchain/verify-contract) * [Transaction receipts](/tavchain/api/transaction) # Get Test TAV Source: https://docs.tavchain.safeney.com/tavchain/faucet Request Test TAV from the faucet, understand the address cooldown and claim process, and review availability and claim-data retention. Request Test TAV to pay for testnet transfers and contract execution. The faucet provides **1 Test TAV per address per 24 hours**, subject to challenge verification and available balance. ## Request tokens 1. Select [Tavchain Testnet](/tavchain/connect) in your wallet and copy your public `0x` address. 2. Open [faucet.tavchain.safeney.com](https://faucet.tavchain.safeney.com/). 3. Enter the address and complete the Cloudflare Turnstile challenge. 4. Follow the claim screen and save the resulting transaction hash. 5. Check the [receipt](/tavchain/api/transaction) and your wallet balance on Tavchain Testnet. A claimable reward or queued request is not a confirmed payout. If the result is unclear, inspect the existing claim and transaction hash before requesting again. The faucet does not require mining, a GitHub account, a mainnet balance or a wallet connection just to paste an address. Never provide a seed phrase, private key or wallet password, and do not buy test tokens. ## Limits and availability Wait 24 hours between claims to the same address. Challenge and abuse protection can also limit requests; see [Troubleshooting](/tavchain/troubleshooting). The faucet has a finite Test TAV balance with no automatic refill. Requests depend on service availability and remaining funds. Its initial allocation is listed in [Tavcoin](/tavchain/learn/tavcoin#testnet-genesis-allocation). ## Claim data Claim records include recipient addresses and IP addresses. Records are retained for **60 days** under the current faucet policy. Review this before making a request. Test TAV is for development and has no monetary value. [Send your first transfer](/tavchain/first-transfer) · [Troubleshooting](/tavchain/troubleshooting) · [Contact support](mailto:support@safeney.com) # Send your first transfer Source: https://docs.tavchain.safeney.com/tavchain/first-transfer Send Test TAV with your wallet, review the recipient and fee, and confirm execution using the transaction receipt and explorer. Send a small amount of **Test Tavcoin (TAV)** using your EVM wallet, then check its receipt and explorer entry. ## Before you begin [Connect to Tavchain](/tavchain/connect) and obtain [1 Test TAV](/tavchain/faucet). Choose an intended recipient's EVM address on this testnet, or another account you control. Do not use an exchange deposit address. ## Send in your wallet 1. Confirm the selected network is Tavchain Testnet, chain ID **771002**. 2. Choose **Send**, enter the recipient's `0x` address and an amount such as **0.01 TAV**. 3. Review the network, full recipient, amount and wallet-estimated maximum fee. Leave enough TAV for fees. 4. Confirm once in your wallet. Save the resulting transaction hash. 5. If the wallet times out or the result is unclear, inspect that hash before submitting another payment. The 0.01 TAV amount is a tutorial example, not a protocol minimum or faucet policy. Fees vary with gas and network conditions; review the current wallet quote. ## Verify execution Open the transaction hash in [the explorer](https://explorer.tavchain.safeney.com/). Check that it succeeded and that the sender, recipient and amount match your transfer. If it is pending or has not appeared, allow time for inclusion and indexing. Check the existing transaction before sending again. A failed transaction can still charge a fee. > [accordion] Check the receipt with JSON-RPC > > Query `eth_getTransactionReceipt` using [the receipt guide](/tavchain/api/transaction). A non-null receipt with `status: "0x1"` means execution succeeded. `status: "0x0"` means execution failed. A `null` result means the endpoint has no receipt at that moment. > > For exact balance accounting, query the same explicit block for related values. Next: [transaction lifecycle](/tavchain/learn/transactions) or [contracts](/tavchain/contracts). ## Related guides * [Developer quickstart](/tavchain/getting-started) * [Release status](/tavchain/status) # Get started with Tavchain Source: https://docs.tavchain.safeney.com/tavchain/getting-started Connect a wallet, get Test TAV and make your first transaction. Start building on Tavchain by connecting a wallet, getting Test TAV and making your first transaction. Use an EVM wallet that supports custom networks and the public RPC endpoint; no node installation is needed. **1. Connect your wallet** [Add Tavchain Testnet](/tavchain/connect), chain ID **771002**, and select it in your wallet. **2. Get Test TAV** Copy your public `0x` address into the [faucet](/tavchain/faucet) and complete the challenge. The faucet provides **1 Test TAV per address per 24 hours**. **3. Send a transfer** Follow [Send your first transfer](/tavchain/first-transfer). Review the network, recipient, amount and fee before signing. **4. Check the result** Open the transaction hash in the [explorer](https://explorer.tavchain.safeney.com/) and check that it succeeded. ## Build next [Build with an AI assistant](/tavchain/ai-tools) using the public Tavchain Docs MCP connection. > [card] [Smart contracts](/tavchain/contracts) > > Compile, deploy, interact and verify source with Remix or Hardhat. > [card] [Ethereum JSON-RPC](/tavchain/http-api) > > Read state, inspect receipts and submit signed transactions. Keep secrets in your wallet. Test TAV has no monetary value. See [Troubleshooting](/tavchain/troubleshooting) if a network, faucet or transaction step fails. # Build and deploy with Hardhat Source: https://docs.tavchain.safeney.com/tavchain/hardhat Build and test an OpenZeppelin ERC-20, deploy it to Tavchain Testnet with Hardhat Ignition, then verify its source without unlocking a signing key. Use the Tavchain Hardhat starter to build and test the same fictional Gold (GLD) token used in the [Remix tutorial](/tavchain/erc20-token). The local testing steps need no wallet, Test TAV or Tavchain node. The later public deployment steps use a dedicated signing account and Test TAV for gas. > [!NOTE] > > The [verified GLD reference contract](#example-deployment) below is deployed on Tavchain Testnet, chain ID **771002**. Deploy your own instance when following this guide. The starter uses Hardhat 3, TypeScript, viem, the Node.js test runner and Ignition. Its contract imports OpenZeppelin's ERC-20 implementation. ## Before you begin Install a maintained, even-numbered Node.js release supported by [Hardhat](https://hardhat.org/docs/reference/nodejs-support), at least **22.13.0**. The reference environment uses **Node.js 24.22.1 on Linux x64**. These instructions have not been validated on Windows or macOS. The first install and compiler download require internet access. ## Download the starter Download [the source ZIP](https://github.com/safeney/Tavchain/releases/download/network-771002-1/tavchain-hardhat-starter3.zip) and its [SHA-256 checksum](https://github.com/safeney/Tavchain/releases/download/network-771002-1/SHA256SUMS). Extract the ZIP and open a terminal in the extracted `tavchain-hardhat-starter3` directory. Archive SHA-256: ```text theme={null} ee213a6c1aac71a633f898c5143f1d58b92c0f641a6bb5a39d1a8ee81c032049 ``` The ZIP contains editable source, configuration, tests, an Ignition module and a dependency lockfile. Dependencies are installed by npm. No Tavchain node binary, wallet or private key is included. The source kit has MIT reuse permission with its included notices. A checksum detects changed bytes. To authenticate the archive, follow the network release's [verification instructions](https://github.com/safeney/Tavchain/releases/download/network-771002-1/VERIFY.md): its signed NETWORK-RELEASE.json includes this ZIP's hash. The archive remains unchanged; its README contains preparation-time and predecessor example references. Use this guide for the current 771002 workflow and deployment. ## Install and compile ```bash theme={null} npm ci --ignore-scripts npm run typecheck npm run build ``` The lockfile fixes dependency versions. Both compiler profiles use **Solidity 0.8.21**, optimization enabled with **200 runs**, and **Shanghai**. The contract creates **1,000 GLD** for the deploying account. GLD has 18 decimals and is a fictional test token. It is separate from Tavchain's native TAV. ## Run the contract tests ```bash theme={null} npm test ``` The three tests check: * Fixed initial supply, deployer balance and Gold/GLD metadata. * A ten-GLD transfer, its Transfer event and resulting balances. * Rejected overdrawing with unchanged balances and supply. A successful test run reports **3 passing**. Tests use Hardhat's in-process development network and publicly known development accounts. > [!WARNING] > > Never fund Hardhat development accounts with valuable assets. These local accounts are for disposable testing. ## Deploy on the local development chain ```bash theme={null} npx hardhat ignition deploy ignition/modules/GLDToken.ts --network hardhatMainnet ``` Ignition reports a successful `GLDTokenModule` deployment and its local address. The in-process network ends when the command exits. Its address and state do not represent a public Tavchain deployment. ## Check the public network without signing ```bash theme={null} npx hardhat run scripts/read-network.ts ``` The script reads the public chain ID and block height without depending on a previous contract deployment. It requires no private key and sends no transaction. Check that the chain ID is **771002**. The network check does not read token balances. Follow [read an ERC-20 balance](/tavchain/api/reference-token) for token reads. ## Prepare a public test account Use a fresh account holding only valueless Test TAV. [Connect to Tavchain Testnet](/tavchain/connect), chain ID **771002**, and obtain [Test TAV from the faucet](/tavchain/faucet). Keep your public account address available so you can check the deployer. Store only this dedicated account's private key through Hardhat's hidden prompt: ```bash theme={null} npx hardhat keystore set TAVCHAIN_PRIVATE_KEY ``` Choose a keystore password and enter the account's private key when requested. Do not enter a recovery phrase, use a valuable mainnet account, paste secrets into chat or commit them to your project. Use the production keystore, without `--dev`. A compromised host or dependency can expose the key while unlocked. Do not use `keystore get`, which prints the secret. ## Deploy to Tavchain Testnet ```bash theme={null} npx hardhat --config hardhat.public.config.ts ignition deploy ignition/modules/GLDToken.ts --network tavchain ``` Unlock the keystore privately. Check Hardhat's network and deployer, then confirm the deployment once. Native transaction value is zero; this constructor creates **1,000 GLD**. Save the successful transaction hash and contract address. The public configuration uses the example settings: maximum fee **2 gwei per gas**, priority fee **0.125 gwei**, five confirmations and no automatic fee increases. These are client settings, not protocol limits or a total-fee guarantee. Check current fees before deploying; the settings may need review if network conditions change. Keep Ignition's deployment journal. If the command fails or its result is unclear, inspect the journal, account nonce and receipt before rerunning. Do not use `--reset` to create a second deployment. ## Verify without unlocking the key Replace `CONTRACT_ADDRESS` with your successful deployment's address: ```bash theme={null} npx hardhat --config hardhat.verify.config.ts verify blockscout --network tavchain CONTRACT_ADDRESS 1000000000000000000000 ``` The verification configuration connects without a local signing key. It needs no password, wallet signature, fee or Etherscan API key. It submits your original source, imports and compiler settings to the hosted Blockscout verifier and checks the result. Open **Contract → Code** in the explorer and require **verified (exact match)**. A transaction receipt or visible bytecode alone is not source verification. This is not a security audit. If verification reports a missing `TAVCHAIN_PRIVATE_KEY`, check that you selected `hardhat.verify.config.ts`. Do not expose a signing key in CI to solve a verification-only connection problem. The npm import path differs from Remix's versioned import. Keep the original build and compiler input for [source verification](/tavchain/verify-contract); do not mix artifacts from the two workflows. ## Example deployment > [accordion] View the deployed GLD example > > The starter's GLD example is deployed on Tavchain Testnet, chain ID **771002**. Open its [verified source and compiler settings](https://explorer.tavchain.safeney.com/address/0x9FEE6A0eAf071Dc6fFa1B6193cE1ab52E085F525?tab=contract) to inspect the original contract and OpenZeppelin imports. > > | Reference | Value | > | - | - | > | Contract | [`0x9FEE6A0eAf071Dc6fFa1B6193cE1ab52E085F525`](https://explorer.tavchain.safeney.com/address/0x9FEE6A0eAf071Dc6fFa1B6193cE1ab52E085F525?tab=contract) | > | Deployment | [Successful transaction](https://explorer.tavchain.safeney.com/tx/0xa62f6eedb3453475d819dbf865fce933cdcdae4e13604d37f135326f91a3b12c) | > | Token transfer | [10-GLD transfer](https://explorer.tavchain.safeney.com/tx/0xa78e1dfc1c66accb0e24bf3d9a1027af564d04382d80a49f7979dcb4f732e7f4) | > | Metadata | Gold (GLD), 18 decimals | > | Initial supply | 1,000 GLD | > | Verification | Exact match, Solidity 0.8.21, Shanghai, optimization enabled with 200 runs | > > At block **10833**, after the demonstrated transfer, the deploying account held **990 GLD** and the recipient held **10 GLD**. Supply remained **1,000 GLD**. Later transactions may change those balances. Deployment and transfer fees totaled **0.000671911875 Test TAV**; this observed fee is not a quote for future transactions. > > The transfer uses the existing token contract's `transfer` method. Follow [Create and transfer an ERC-20 token](/tavchain/erc20-token#transfer-10-gld) to perform a transfer with your own deployed instance. The downloadable starter's Ignition module deploys the token; it does not include a separate public-transfer module. > > Deploy your own instance when following the guide. Its address, transaction hash and fee will differ. The source retains the kit's MIT notice and third-party notices. ## Related guides * [EVM contract workflow](/tavchain/contracts) * [Create and transfer an ERC-20 token](/tavchain/erc20-token) * [Network settings](/tavchain/connect) * [Release status](/tavchain/status) # Ethereum JSON-RPC Source: https://docs.tavchain.safeney.com/tavchain/http-api Use Tavchain HTTP Ethereum JSON-RPC for state queries and signed transactions, with endpoint details, common methods, limits and errors. Use Tavchain's HTTP Ethereum JSON-RPC endpoint to read chain state and submit locally signed transactions. **Endpoint:** `https://api.testnet.tavchain.safeney.com/`\ **EVM chain ID:** `771002` (`0xbc3ba`) Send JSON-RPC 2.0 requests with HTTP POST and `Content-Type: application/json`. The RPC URL is an API endpoint, not a web page; opening it with a browser GET request or checking it with HEAD can return HTTP 404 even while POST requests work. For queries from a coding assistant, see [Read live blockchain data with AI](/tavchain/ai-chain). ## Example request ```bash theme={null} set -e curl --fail-with-body --max-time 10 \ https://api.testnet.tavchain.safeney.com/ \ -H 'Content-Type: application/json' \ --data '{"jsonrpc":"2.0","id":1,"method":"eth_chainId","params":[]}' ``` The expected chain ID result is `"0xbc3ba"`. ## Common methods | Task | Method | Reference | | - | - | - | | Identify the network | `eth_chainId` | [Network identity](/tavchain/api/network-selection) | | Read the head | `eth_blockNumber` | [Network identity](/tavchain/api/network-selection) | | Read native balance | `eth_getBalance` | [Balance and nonce](/tavchain/api/account) | | Read account nonce | `eth_getTransactionCount` | [Balance and nonce](/tavchain/api/account) | | Read contract state | `eth_call` | [Token balance](/tavchain/api/reference-token) | | Estimate execution | `eth_estimateGas` | [Gas fees](/tavchain/learn/fees) | | Submit signed bytes | `eth_sendRawTransaction` | [Submission](/tavchain/api/submit-transaction) | | Inspect execution | `eth_getTransactionReceipt` | [Receipts](/tavchain/api/transaction) | | Read a block | `eth_getBlockByNumber` | [Node monitoring](/tavchain/operate/monitoring#compare-a-fixed-block) | Public namespaces are `eth`, `net` and `web3`. The service does not unlock server accounts. Public WebSocket RPC and debug tracing are not offered. ## Usage limits | Limit | Public endpoint | | - | - | | HTTP request rate per IP | 10 requests/second, burst 20 | | Aggregate HTTP request rate | 100 requests/second, burst 100 | | Concurrent requests | 10 per IP, 100 overall | | Request size | 1 MiB | | JSON-RPC batch size | 50 requests | | `eth_call` execution | 10 million gas, 5 seconds | | Log query | 1,000 blocks and 1,000 results | Shared-IP users share the per-IP quota. Excess traffic returns HTTP **429**. These API protection settings are not a network throughput benchmark. ## Handle responses and errors Inspect both the HTTP status and JSON body. A JSON-RPC response has a matching `id` and either `result` or `error`. Network and HTTP errors can occur before a JSON-RPC response exists. Back off before retrying read requests. For an uncertain transaction submission, inspect the original hash and receipt before making a replacement. [Response formats](/tavchain/api/schemas) · [Interface overview](/tavchain/api/openapi) · [Troubleshooting](/tavchain/troubleshooting) # Developer documentation Source: https://docs.tavchain.safeney.com/tavchain/index Choose a Tavchain development workflow for wallets, Solidity contracts and Ethereum JSON-RPC, with links to setup and troubleshooting. Build on Tavchain Testnet with Ethereum-compatible wallets, Solidity and JSON-RPC. Choose a workflow based on what you want to do. > [card] [First transaction](/tavchain/getting-started) > > Connect a wallet, request Test TAV and send a transfer. > [card] [Smart contracts](/tavchain/contracts) > > Choose Remix for a browser workflow or Hardhat for a local project. > [card] [RPC reference](/tavchain/http-api) > > Read chain data and submit locally signed transactions. > [card] [Troubleshooting](/tavchain/troubleshooting) > > Resolve network-selection, faucet and transaction problems. Use [Network information](/tavchain/network) for the chain ID, endpoints and native currency. Learn about [accounts](/tavchain/learn/accounts), [gas fees](/tavchain/learn/fees) and [transaction execution](/tavchain/learn/transactions) as you build. # Accounts and self-custody Source: https://docs.tavchain.safeney.com/tavchain/learn/accounts Understand Tavchain EVM accounts, wallet custody, chain-specific balances and the distinction between native and EVM address formats. Tavchain uses Ethereum-style accounts with public `0x` addresses. The browser tutorials use an **externally owned account (EOA)**, controlled by a private signing key that your wallet manages. A **contract account** is controlled by its deployed code rather than a private key. It executes when called by a transaction or another contract. Both account types can hold TAV; their permissions and behavior differ. ## Keep custody of your keys Use a dedicated test account. Never paste a seed phrase, private key or wallet password into the faucet, explorer or support messages. Public services need your address or transaction hash, not your signing key. ## Select the correct network The same address format can appear on several EVM networks. Balances, nonces and deployed contracts are specific to each chain. Select Tavchain Testnet, chain ID **771002**, before reviewing a transaction. ## Native and EVM addresses Native node tooling can show the corresponding account in `tav1…` form. Use the EVM `0x` address for wallet, faucet and Ethereum JSON-RPC workflows. Do not convert between representations by truncating or editing address text. [Connect a wallet](/tavchain/connect) · [TAV and token balances](/tavchain/learn/tokens) · [Transaction lifecycle](/tavchain/learn/transactions) # Network architecture Source: https://docs.tavchain.safeney.com/tavchain/learn/architecture Understand how Tavchain consensus, EVM execution, full nodes and public services fit together, with links to the network security model. Tavchain is an independent EVM Layer 1. Its node application combines a Cosmos SDK application, CometBFT-family consensus and EVM execution, derived from Cronos 1.8.1. ## Protocol and application access Validators agree on blocks and execute the chain's state transitions. A non-validator full node follows and verifies the same history without participating in consensus voting. Wallets and applications use Ethereum JSON-RPC to read state, estimate execution and submit signed transactions. Native node tools use the chain's native RPC and identifiers. The two interfaces serve different audiences. ## Supporting services * **RPC** provides application access to chain data and transaction submission. * **Explorer** indexes blocks, transactions, contracts and token activity. * **Faucet** distributes Test TAV for development. These services do not hold a user's wallet signing key. Explorer indexing and service availability are distinct from consensus and can lag or fail independently. ## Trust boundaries Tavchain does not settle to Ethereum and does not inherit Base or Celo's rollup security. The initial testnet validators are administered together. Multiple validators share a hosting failure domain, so validator count alone does not imply independent operation. Read [Consensus, finality and security](/tavchain/learn/security) for the control and availability assumptions. [Node roles](/tavchain/operate/node-roles) · [Network settings](/tavchain/network) · [Protocol overview](/tavchain/learn/protocol) # Cross-chain connectivity Source: https://docs.tavchain.safeney.com/tavchain/learn/bridging Check Tavchain cross-chain availability and understand why EVM-compatible addresses do not provide bridging or asset conversion. Tavchain Testnet does not currently provide an official bridge, wrapped asset or IBC token-transfer route. ## Network separation EVM compatibility lets developers reuse familiar tooling. It does not transfer assets between networks. Matching `0x` address formats do not make balances interchangeable. Do not send mainnet assets or another chain's tokens to a Tavchain address expecting conversion. Test TAV has no monetary value and no announced mainnet redemption route. ## Fund development Use the [Tavchain faucet](/tavchain/faucet) for Test TAV and verify the selected [network settings](/tavchain/network) before sending a transaction. [Current capabilities](/tavchain/status) · [Accounts and networks](/tavchain/learn/accounts) # Fees and resource limits Source: https://docs.tavchain.safeney.com/tavchain/learn/fees Learn how gas is paid in Test TAV, how to estimate transaction fees and why execution gas differs from public RPC usage limits. Tavchain transactions pay gas in Test TAV. The amount of gas depends on the work performed: a native transfer and a contract deployment can have different costs. ## Estimate before signing Let your wallet or compatible tool estimate gas and display the fee. Review that quote before approving a transaction and leave enough TAV in the sender account to pay it. A failed execution can still charge gas. Fees vary with execution and network conditions. A recorded tutorial fee is not a current quote, and there is no fixed fiat price for Test TAV. ## Amounts and precision TAV has 18 decimals. Base amounts are integer `atav` values; Ethereum RPC quantity fields use hexadecimal. Use integer-safe conversion when displaying balances and fees. ## Gas versus API limits Transaction gas meters execution. RPC rate, batch and query limits protect the public API and are documented in [Ethereum JSON-RPC](/tavchain/http-api). They are not a network throughput benchmark or a transaction-fee schedule. [Get Test TAV](/tavchain/faucet) · [Tavcoin units](/tavchain/learn/tavcoin) · [Transaction lifecycle](/tavchain/learn/transactions) # Glossary Source: https://docs.tavchain.safeney.com/tavchain/learn/glossary Definitions of Tavchain account, transaction, token and node terminology, including chain IDs, gas, receipts and base units. Use this glossary to interpret Tavchain's network, transaction and node documentation. | Term | Meaning | | - | - | | EVM | The execution environment for Ethereum-compatible contract bytecode. | | EVM chain ID | The numeric identity used by wallets when signing. Tavchain Testnet uses `771002`. | | Native chain ID | The node identifier, `tavchaintestnet_771002-1`. | | Tavcoin (TAV) | The native coin used for transaction value and fees. Test TAV has no monetary value. | | atav | TAV's base denomination. `1 TAV = 10^18 atav`. | | Gas | The unit that meters transaction execution work. | | Nonce | An account's transaction sequence number. | | Receipt | The execution result for an included transaction. | | Validator | A node admitted to the consensus validator set. | | Full node | A node that follows and verifies the chain without necessarily voting in consensus. | | RPC | The interface used by wallets and applications to query state and submit transactions. | | Explorer | A service that indexes chain data for browsing. Its index can lag the chain. | | Faucet | A service that distributes valueless test tokens for development. | | ERC-20 | A token contract interface; its balances are separate from native TAV. | [Network information](/tavchain/network) · [Transaction lifecycle](/tavchain/learn/transactions) · [Node roles](/tavchain/operate/node-roles) # Governance and upgrades Source: https://docs.tavchain.safeney.com/tavchain/learn/governance Learn the testnet governance thresholds, proposal deposits and relationship between voting power and validator participation. Tavchain Testnet uses the native Cosmos SDK governance module. Governance decisions use bonded voting power, not a count of wallet addresses. The initial validator set remains under shared administration. ## Proposal parameters | Parameter | Value | | - | - | | Ordinary proposal minimum deposit | 100 Test TAV | | Ordinary voting period | 24 hours | | Quorum | 0.334 of eligible voting power | | Approval threshold | 0.5, applied by the native tally rules | | Veto threshold | 0.334, applied by the native tally rules | | Expedited minimum deposit | 500 Test TAV | | Expedited voting period | 6 hours | Native tally rules distinguish Yes, No, Abstain and NoWithVeto. Do not infer passage from a simple percentage of accounts. A proposal that passes voting can still fail when its requested action executes. Deposit return or burning depends on the outcome and configured rules; it is not guaranteed. ## Participate safely Use the native CLI's current governance queries and command help for the selected chain. MetaMask's EVM chain-ID field is not the native CLI chain ID. Verify [network identity](/tavchain/network), proposal content, deposit, gas and fee before signing. Never share wallet secrets with support. Governance does not make centrally controlled validators independent. Software upgrades require coordinated operator procedures. See [Staking](/tavchain/learn/staking) and [Upgrades and recovery](/tavchain/operate/upgrades-recovery). # Development and roadmap Source: https://docs.tavchain.safeney.com/tavchain/learn/history Understand the current Tavchain development scope, available testnet workflows and features that are not yet enabled. Tavchain's direction is a general-purpose blockchain for smart contracts and applications, shaped by Africa's needs and open to builders worldwide. This page separates that direction from the workflows currently available on Tavchain Testnet. ## Development direction The focus is a reusable platform and a straightforward developer experience. Developers can build applications across payments, finance, DeFi, digital assets and other sectors, rather than being limited to one industry. Current work builds on wallet access, Solidity development, contract verification, public source and node tooling. Future application categories are opportunities for builders, not announced Tavchain products or delivery commitments. ## Available workflows * Custom-network wallet connection and native TAV transfers. * Test-token funding through the faucet. * Solidity deployment and interaction through Remix and Hardhat. * Contract-source verification through the explorer. * Public full-node synchronization and Linux service operation. See [Release information](/tavchain/status) for supported interfaces and software. ## Participation and connectivity The testnet enables native TAV staking, delegation, fee distribution and governance. The initial validators remain centrally operated, and no official cross-chain bridge is available. No mainnet launch date or conversion of test balances is announced. ## Earlier development The earlier custom Rust/WASM prototype used a different network and transaction format. Current instructions apply to the Cronos-derived EVM testnet. Old prototype clients and balances are not interchangeable with this network. [Start building](/tavchain/getting-started) · [Network identity](/tavchain/network) # Protocol overview Source: https://docs.tavchain.safeney.com/tavchain/learn/protocol Learn how Tavchain combines consensus, EVM execution and native node interfaces, including validator admission and network identity. Tavchain Testnet uses the Cronos-derived Cosmos SDK application and CometBFT-family consensus to execute an EVM-compatible ledger. Applications interact with that ledger through Ethereum JSON-RPC. ## Network identifiers Wallets sign for EVM chain ID `771002`. Native nodes identify the chain as `tavchaintestnet_771002-1`. The [network reference](/tavchain/network) lists the current endpoints and genesis identity. ## Consensus participation The initial validator set is under shared administration. Only active validators vote on blocks. Running a full node or holding Test TAV does not enroll an account as a validator. Validator membership and voting power are chain state and can change. Do not infer consensus power from a wallet's TAV balance or assume every validator has equal power. ## EVM execution Tavchain executes Ethereum-style contract bytecode. Use Solidity and the [documented development tools](/tavchain/contracts). The chain ID, gas, account nonce and transaction signature identify how an EVM transaction is processed. EVM compatibility does not imply that every upstream module, opcode revision, precompile or integration is enabled. Refer to [release capabilities](/tavchain/status) and the settings in each guide. [Transaction lifecycle](/tavchain/learn/transactions) · [Architecture](/tavchain/learn/architecture) · [Security](/tavchain/learn/security) # Network rewards Source: https://docs.tavchain.safeney.com/tavchain/learn/rewards Understand how transaction fees, validator commission and delegator shares relate to the testnet, without a promised yield. Tavchain Testnet distributes transaction fees through the native distribution module. It does not mint inflationary rewards: the configured inflation rate is zero. ## Fee distribution The community pool receives 2% of distributed fees. Validator commission and delegator shares are accounted for by the distribution module. A validator's commission rate and bonded stake affect each delegation's share. Empty blocks do not create an inflation subsidy, and transaction activity does not guarantee a particular return. Withdrawable rewards, commission and fractional accounting are distinct. A displayed accrued amount is not necessarily an already withdrawn wallet balance. Check native queries before submitting a withdrawal, and keep all raw amounts in integer-safe types. ## Faucet and application tokens A [faucet claim](/tavchain/faucet) is development funding, not a consensus reward. Tokens created by [smart contracts](/tavchain/contracts) follow those contracts' rules, not the native staking distribution rules. Test TAV has no monetary value. Participation does not promise income, an airdrop, redemption or mainnet allocation. Read [Staking and delegation](/tavchain/learn/staking) and the [security model](/tavchain/learn/security). # Consensus, finality and security Source: https://docs.tavchain.safeney.com/tavchain/learn/security Read Tavchain Testnet consensus and validator trust assumptions, availability risks, wallet safety and private vulnerability reporting guidance. Tavchain Testnet is an unaudited network. Understand its validator control, availability and application risks before using it. ## Consensus and finality The validator set uses CometBFT-family consensus. A block is committed after valid precommits representing **more than two-thirds of the current validator voting power**. The threshold uses voting power, not the number of nodes. Under the consensus assumptions, including less than one-third faulty voting power, committed blocks have deterministic finality. Quorum loss can halt new blocks. Waiting for extra confirmations does not remove shared-administration risk, and Tavchain does not wait for settlement on Ethereum. A full node verifies the chain, while applications commonly rely on RPC responses and transaction receipts. A successful receipt records execution in a block. It does not audit a contract, establish a token's value or guarantee the correctness of an explorer index. ## Validator control and availability The current testnet has four validators under shared administration. They are not four independent operators. Several validators share one hosting failure domain; an outage affecting that group can halt consensus, and compromise of a quorum can compromise the network. Public RPC and explorer users rely on those services to report chain state. Running a [full node](/tavchain/operate) provides a separate local verification path, but does not change the validator control model. ## Accounts and contracts Keep wallet seeds, private keys and passwords private. Neither the faucet nor support needs them. Use dedicated test accounts and do not deposit real assets. Test TAV has no monetary value, and demonstration contracts are not audited financial products. ## Report a vulnerability Email [support@safeney.com](mailto:support@safeney.com) with the subject **Tavchain security report**. Describe the affected component, impact and safe reproduction steps. Do not publish sensitive exploitation details or include credentials. See [reporting guidance](/tavchain/contribute/reporting#report-a-security-concern). [Network reference](/tavchain/network) · [Governance and upgrades](/tavchain/learn/governance) # Staking and delegation Source: https://docs.tavchain.safeney.com/tavchain/learn/staking Understand TAV self-bonding, delegation, validator voting power and the testnet unbonding period before participating. Tavchain Testnet uses the native Cosmos SDK staking module with `atav` as its bond denomination. Staking commits Test TAV to a validator; it is separate from running an unregistered full node. ## Validator and delegator roles A validator registers its consensus public key and self-delegation through the native node CLI. Delegators bond Test TAV to a validator and share its fee-derived rewards after the validator's commission. The active set can contain up to 10 validators, selected by bonded stake. Funding an account or submitting a registration does not guarantee active voting power. The initial four validators remain under shared administration. Validator grants are a controlled distribution of test tokens, not proof of independent operation or automatic membership. Contact [support](/tavchain/contribute/reporting) for participation information; never send a private key or keyring passphrase. ## Unbonding and penalties The configured unbonding period is 21 days. Staked funds can be affected by downtime and double-signing penalties. Validator commission is configured by each validator subject to its declared limits. Check the current chain's staking and slashing parameters before acting. Test TAV has no monetary value. Staking does not promise a yield, airdrop, mainnet allocation or real-world return. See [Network rewards](/tavchain/learn/rewards), [Governance](/tavchain/learn/governance) and [Node roles](/tavchain/operate/node-roles). # Tavcoin Source: https://docs.tavchain.safeney.com/tavchain/learn/tavcoin Understand Tavcoin, its 18-decimal base units, testnet genesis allocation and the difference between Test TAV and application tokens. Tavcoin (**TAV**) is Tavchain's native coin. Use Test TAV on testnet to send value and pay transaction fees. Test TAV has no monetary value. ## Units and precision TAV has **18 decimal places**. Its base denomination is `atav`. | Display amount | Base amount | | - | - | | 1 TAV | 1,000,000,000,000,000,000 atav | | 0.01 TAV | 10,000,000,000,000,000 atav | | Smallest unit | 1 atav = 0.000000000000000001 TAV | Wallets display TAV amounts. Ethereum RPC represents balances and other quantity fields as hexadecimal integers. Keep base amounts in integer-safe types; do not use floating-point arithmetic for account balances. ## Testnet genesis allocation The testnet genesis allocates a total of **1,000,000 Test TAV**: | Allocation | Test TAV | | - | - | | Four operator accounts | 2,000 each | | Faucet | 50,000 | | Validator-grant reserve | 50,000 | | Test reserve | 892,000 | Each genesis validator self-bonds 1,000 Test TAV from its operator allocation. The reserve does not automatically refill the faucet. This describes the testnet genesis, not mainnet tokenomics or a promise of rewards. Test balances have no announced redemption, airdrop or mainnet conversion entitlement. [Get Test TAV](/tavchain/faucet) · [Gas fees](/tavchain/learn/fees) · [Application tokens](/tavchain/learn/tokens) # Native TAV and application tokens Source: https://docs.tavchain.safeney.com/tavchain/learn/tokens Distinguish native TAV from ERC-20 assets, identify tokens by chain and contract address, and handle token decimals and gas correctly. Tavchain has a native coin, TAV, and supports smart-contract tokens such as ERC-20s. Their balances and uses are different. ## Native TAV Use TAV for native transfers and transaction gas. On testnet, obtain valueless Test TAV from the [faucet](/tavchain/faucet). Read its balance with `eth_getBalance`. ## Contract tokens An ERC-20 records token balances in a smart contract. Identify it by **network and contract address**, not its ticker alone. Two contracts can use the same symbol without representing the same asset. Read a token's own `decimals()` when displaying amounts. Its decimals do not have to match native TAV's 18 decimals. An ERC-20 balance does not replace the TAV needed for gas. ## Build an example token Follow [Create and transfer an ERC-20 token](/tavchain/erc20-token) to deploy OpenZeppelin's Gold (GLD) example, read its supply and transfer tokens. GLD is a fictional demonstration, not gold-backed or an official Tavchain asset. [Read a token balance](/tavchain/api/reference-token) · [Tavcoin units](/tavchain/learn/tavcoin) # Transaction lifecycle Source: https://docs.tavchain.safeney.com/tavchain/learn/transactions Follow a Tavchain transaction from local signing and submission to execution, receipt inspection and explorer indexing. A Tavchain transaction requests a change to chain state. Your wallet or signing library prepares it for the selected network, signs it locally and submits the signed bytes through RPC. ## Transaction stages 1. **Prepare:** select chain ID `771002`, recipient or contract, amount, nonce and fee settings. 2. **Sign:** review the details and approve with your wallet or local signer. 3. **Submit:** RPC returns a transaction hash for lookup. 4. **Execute:** an included transaction receives an execution result in a block. 5. **Inspect:** read its receipt and, optionally, view it in the explorer. A returned transaction hash is not an execution result. ## Receipt status | Result from `eth_getTransactionReceipt` | Meaning | | - | - | | `null` | This endpoint does not have a receipt at that moment. | | `status: "0x1"` | Execution succeeded. | | `status: "0x0"` | Execution failed; gas may still be charged and the nonce consumed. | If submission times out, check the original hash before sending a replacement. A replacement is a deliberate nonce and fee decision. ## Read-only calls Use `eth_call` to read contract state without submitting a transaction. A state-changing contract method needs a signed transaction and gas. The explorer indexes chain data asynchronously. If it has not listed a transaction yet, check the RPC receipt and allow time for indexing. [Send your first transfer](/tavchain/first-transfer) · [Receipt reference](/tavchain/api/transaction) · [Fees](/tavchain/learn/fees) # Wallets, tools and services Source: https://docs.tavchain.safeney.com/tavchain/learn/wallets Choose a wallet or development tool for Tavchain Testnet and understand the distinct roles of wallets, RPC, the faucet and explorer. Use an EVM wallet that supports custom networks to connect to Tavchain Testnet. MetaMask is the reference wallet for the browser tutorials. ## Wallets and services | Component | Role | | - | - | | Wallet | Holds signing keys, displays accounts and requests transaction approval. | | RPC | Reports chain state and relays signed transactions. | | Faucet | Distributes Test TAV for development. | | Explorer | Indexes blocks, transactions, contracts and tokens for browsing. | Adding a network does not give its RPC server access to your wallet key. Read-only RPC requests do not require a wallet signature. ## Development tools Use [Remix](/tavchain/write-contract) for a browser-based Solidity workflow or the [Hardhat starter](/tavchain/hardhat) for a local TypeScript project. Both use Ethereum-compatible interfaces with Tavchain's chain ID and endpoints. Other wallets, hardware signers and browser combinations can differ in behavior. EVM compatibility alone does not establish support for every platform. Check the selected network and review each request before approving it. [Connect to Tavchain](/tavchain/connect) · [Network information](/tavchain/network) # Network information Source: https://docs.tavchain.safeney.com/tavchain/network Tavchain Testnet chain IDs, RPC URL, currency, explorer, faucet, address formats and genesis identity for wallets and node operators. Use the following settings to connect wallets and applications to Tavchain Testnet. Wallets use the numeric EVM chain ID; native node tools use the separate native identifier. > [!NOTE] > > This testnet uses EVM chain ID 771002. Balances, account nonces and contracts from the previous 771001 networks are not carried forward. Select the new wallet network and request fresh Test TAV from the faucet. ## Testnet settings | Setting | Value | | - | - | | Network name | Tavchain Testnet | | EVM chain ID | `771002` (hex `0xbc3ba`) | | RPC URL | `https://api.testnet.tavchain.safeney.com/` | | Native currency | Tavcoin (`TAV`), 18 decimals | | Explorer | `https://explorer.tavchain.safeney.com/` | | Faucet | `https://faucet.tavchain.safeney.com/` | ## Native network identity The native chain ID is `tavchaintestnet_771002-1`. Do not enter this string in a wallet's numeric chain-ID field. The genesis SHA-256 is: ```text theme={null} a101ab9ccf1478757af8a69d832548ea1167e552fe6d6ef6621a77447a54e924 ``` Use the [signed release and network files](/tavchain/operate/network-assets) when installing a node. ## Address formats EVM addresses contain `0x` followed by 40 hexadecimal characters. Transaction hashes contain `0x` followed by 64 hexadecimal characters. Native tooling can display the corresponding account in `tav1…` form. Use the EVM address for wallets, the faucet and Ethereum JSON-RPC. ## Availability and security Public RPC is a best-effort service with [usage limits](/tavchain/http-api). The explorer is an index of chain data. Read the [security model](/tavchain/learn/security) for the network's validator and trust assumptions. Test TAV has no monetary value. Do not send assets from another network expecting conversion. [Connect a wallet](/tavchain/connect) · [Run a full node](/tavchain/operate) # Operate Tavchain Source: https://docs.tavchain.safeney.com/tavchain/operate Understand node roles, network access and the current operating model. Run a Tavchain Testnet full node to follow blocks and use your own local RPC. If you only want to connect a wallet or build an application, start with [Connect to Tavchain](/tavchain/connect). ## Choose an installation > [card] [Docker](/tavchain/operate/node-docker) > > Recommended starting point on Linux x86-64. Pull the published image with Compose. The client and network defaults are included; no local build is required. > [card] [Native binaries](/tavchain/operate/node-native) > > Download a ready-to-run bundle for Linux x86-64, Linux ARM64 or Windows x86-64, then initialize and start. Both routes create a full node, not a registered validator. The testnet remains under shared administration. Read [Node roles](/tavchain/operate/node-roles) for participation details and [Release compatibility](/tavchain/status#release-compatibility) for supported platforms. ## Maintain your node > [card] [Monitor](/tavchain/operate/monitoring) > > Check sync, peers, block agreement and host health. > [card] [Troubleshoot](/tavchain/operate/troubleshooting) > > Resolve startup, connectivity and storage problems. > [card] [Upgrades and recovery](/tavchain/operate/upgrades-recovery) > > Maintain your node while preserving its identity and data. > [card] [Network reference](/tavchain/operate/network-assets) > > Find genesis, public peers, ports, authenticated downloads and source. ## Other installation options The [earlier Linux x86-64 guide](/tavchain/operate/run-full-node) remains available for that client release. Its [systemd guide](/tavchain/operate/node-service) covers background service operation. Follow those guides together; they use a different client package from the newer native binaries. ## Validator participation A full node verifies history without voting in consensus. Validator registration and active membership use native staking and delegation. The initial validators remain under shared administration. Read [Node roles](/tavchain/operate/node-roles), [Staking](/tavchain/learn/staking) and the [security model](/tavchain/learn/security). For support, email [support@safeney.com](mailto:support@safeney.com) with your client version, public block height and sanitized error. # Monitor a node Source: https://docs.tavchain.safeney.com/tavchain/operate/monitoring Check sync, peers, block agreement and host health with native RPC and systemd. Know whether your full node is ready before using its RPC. A running process is only the first check: it must also follow the correct network, advance with its peers and agree on blocks. The published [native bundles](/tavchain/operate/node-native), [Docker setup](/tavchain/operate/node-docker) and [earlier Linux installation](/tavchain/operate/run-full-node) expose the local RPC endpoints used below. Run the checks from the node's host. On Windows, open the status URLs in a browser or use `curl.exe` rather than the PowerShell `curl` alias. The Bash examples require a compatible shell; the Python comparison requires Python 3. The systemd and `/var/lib/tavchain-fullnode` checks apply only to the [earlier service installation](/tavchain/operate/node-service). Docker and native bundles do not create that service. The commands below read status; they do not change configuration or submit transactions. ## Check network and sync ```bash theme={null} set -e curl --fail --silent --show-error --max-time 15 http://127.0.0.1:29657/status | python3 -m json.tool curl --fail --silent --show-error --max-time 15 http://127.0.0.1:29657/net_info | python3 -m json.tool ``` | Field | Healthy interpretation | | - | - | | `result.node_info.network` | `tavchaintestnet_771002-1` | | `result.sync_info.latest_block_height` | Increases over repeated observations and catches up toward the network tip | | `result.sync_info.latest_block_time` | Advances with the height; interpret timestamps using a correctly synchronized host clock | | `result.sync_info.catching_up` | Becomes `false` after initial sync; use block agreement and progress as additional checks | | `result.n_peers` from `/net_info` | At least one connected peer is needed for network sync; a nonzero count alone does not prove readiness | | `result.validator_info.voting_power` | `0` is normal for an unregistered non-validator full node | Repeat the status request later to check progress. A historical block height or `catching_up: false` from one observation is not a continuing health guarantee. A registered validator with zero voting power needs validator-specific investigation; an observer does not need to unjail itself. ## Check the EVM interface ```bash theme={null} set -e curl --fail --silent --show-error --max-time 15 http://127.0.0.1:29645/ -H 'Content-Type: application/json' --data '{"jsonrpc":"2.0","id":1,"method":"eth_chainId","params":[]}' curl --fail --silent --show-error --max-time 15 http://127.0.0.1:29645/ -H 'Content-Type: application/json' --data '{"jsonrpc":"2.0","id":2,"method":"eth_blockNumber","params":[]}' ``` Expect chain ID `0xbc3ba` (771002). EVM block numbers are hexadecimal. An HTTP success can still contain a JSON-RPC `error`; inspect the response body. A correct chain ID alone does not prove block agreement. ## Compare a fixed block Run this with Python 3 while your node is running. It queries the local node and the public Tavchain reference, chooses one common height below both tips and compares that block's hash. It makes no wallet connection or transaction. ```bash theme={null} python3 - <<'PYCODE' import json import urllib.request local = "http://127.0.0.1:29645/" reference = "https://api.testnet.tavchain.safeney.com/" def rpc(url, method, params): request = urllib.request.Request( url, data=json.dumps({"jsonrpc": "2.0", "id": 1, "method": method, "params": params}).encode(), headers={"Content-Type": "application/json"}, ) with urllib.request.urlopen(request, timeout=15) as response: body = json.load(response) if "error" in body: raise RuntimeError(body["error"]) return body["result"] for endpoint in (local, reference): if int(rpc(endpoint, "eth_chainId", []), 16) != 771002: raise SystemExit("Wrong chain ID: stop and inspect the selected endpoint") local_tip = int(rpc(local, "eth_blockNumber", []), 16) reference_tip = int(rpc(reference, "eth_blockNumber", []), 16) height = min(local_tip, reference_tip) - 1 if height < 1: raise SystemExit("Not enough blocks yet; wait for sync") blocks = [rpc(endpoint, "eth_getBlockByNumber", [hex(height), False]) for endpoint in (local, reference)] if any(block is None for block in blocks): raise SystemExit("Block unavailable; inspect sync and endpoint health") if any(int(block["number"], 16) != height for block in blocks): raise SystemExit("Unexpected block height in response") if blocks[0]["hash"] != blocks[1]["hash"]: raise SystemExit("BLOCK MISMATCH: preserve state and investigate before using this node") print(json.dumps({"local_tip": local_tip, "reference_tip": reference_tip, "compared_height": height, "block_hash": blocks[0]["hash"], "match": True}, indent=2)) PYCODE ``` A matching old block does not prove that the node has reached the tip. Review both reported tips and continuing progress. A mismatch needs investigation; do not reset or erase the node. A reference timeout or rate limit makes this comparison inconclusive. Public RPC may return HTTP 429; avoid rapid polling and retry later. The public reference is a hosted Tavchain service. Agreement is useful diagnostics, not an independent trust source or an audit of the network. ## Check the process and host For the published systemd profile: ```bash theme={null} sudo systemctl status tavchain-fullnode.service --no-pager sudo systemctl show tavchain-fullnode.service --property=ActiveState,SubState,Result,NRestarts sudo journalctl -u tavchain-fullnode.service -n 100 --no-pager sudo df -h /var/lib/tavchain-fullnode sudo df -i /var/lib/tavchain-fullnode timedatectl status ``` Inspect repeated errors, unexpected restarts, free disk space, free inodes and clock synchronization. Check the filesystem holding your actual home if you chose another path. The profile retains full history, so plan for continuing storage growth. Set host alerts according to your workload and storage growth; this guide does not prescribe universal capacity thresholds. Keep a record of normal sync progress and resource use on your host. Investigate sustained lag, stopped block progress, lost peers, recurring errors or shrinking free space before the node becomes unavailable. See [Troubleshoot a node](/tavchain/operate/troubleshooting) for symptom-specific checks. ## Dashboards and alerting The packaged full-node profile leaves its metrics endpoint disabled and does not include a Prometheus/Grafana deployment. The local RPC and systemd checks above are available without a dashboard stack. Hosting a full node does not automatically enroll it in Tavchain's service monitoring. Arrange monitoring for your own host. A monitor on the same host can fail during the same outage; consider that failure domain when planning availability checks. Keep private node interfaces protected. # Network files and ports Source: https://docs.tavchain.safeney.com/tavchain/operate/network-assets Verify the 771002 genesis, public peers and observer configuration alongside the unchanged Tavchain node release. Tavchain's network files select native network `tavchaintestnet_771002-1` and EVM chain ID `771002`. For a new node, use the [installation chooser](/tavchain/operate). The published Docker image and native bundles include the matching configuration; separate network-file assembly is for the earlier manual client installation. | Setting | Value | | - | - | | EVM chain ID | 771002 (`0xbc3ba`) | | Native chain ID | tavchaintestnet\_771002-1 | | Native asset | Tavcoin (TAV), 18 decimals, base denomination atav | | Genesis SHA-256 | a101ab9ccf1478757af8a69d832548ea1167e552fe6d6ef6621a77447a54e924 | | Support | [support@safeney.com](mailto:support@safeney.com) | ## Choose the matching release | Installation | Authenticated package | | - | - | | Native bundle | [Native bundle release](https://github.com/safeney/Tavchain/releases/tag/native-bundle-771002-1), with `BUNDLE-RELEASE.json`, its detached signature and `VERIFY.md`. Client `1.8.1-tavchain.eval1-native1`, runtime libraries and network files are included. | | Prebuilt Docker image | [Docker guide](/tavchain/operate/node-docker), with an exact image digest in the registry Compose file. Client `1.8.1-tavchain.eval1` and network defaults are included. | | Earlier manual Linux client | [Earlier installation](/tavchain/operate/run-full-node), using the binary and network manifests separately. This is also the client used by the existing systemd guide. | The earlier client archive contains historical network files. Its manual installation replaces them with the authenticated 771002 files before initializing a fresh node. Do not replace genesis or configuration in an existing home as an upgrade shortcut. Download base: `https://testnet.tavchain.safeney.com/downloads/tavchain-network-771002-1`. The package contains `genesis.json`, `config.toml`, `app.toml`, `peers.txt`, `network.json`, `README.md`, `VERIFY.md`, `SHA256SUMS` and `tavchain-network-771002-1.tar.gz`. Its signed manifest is `NETWORK-RELEASE.json` with detached `NETWORK-RELEASE.json.sig`. Use the trusted fingerprint `SHA256:rZRDFiztp0bd51gCAI/qKBGxkOKl9Fv52UWdbUpUQRM`, principal `safeney-tavchain-releases` and namespace `tavchain-release-v1`. Signed release metadata records the package at preparation time. Check the [network reference](/tavchain/network) and current RPC for live network identity. Checksums alone do not establish publisher identity. A checksum or signature does not prove that a network is public or that synchronization succeeded. The node executable and application/dependency source archives remain at the [existing client release](https://testnet.tavchain.safeney.com/downloads/tavchain-node-1.8.1-tavchain.eval1/RELEASE.json). Dependencies retain their existing licenses and notices. The newer [native release](/tavchain/operate/node-native) provides tested Linux x86-64, Linux ARM64 and Windows x86-64 full-node binaries with a separate signed manifest. Its exact source and packaging changes are provided alongside the binaries. Browse the [Tavchain node source and public network files](https://github.com/safeney/Tavchain). For installation and reproducible builds, continue to use the authenticated release archives and their exact build instructions. ## Docker package For a new Linux x86-64 node, follow [Run a node with Docker](/tavchain/operate/node-docker). Its [public image](https://github.com/safeney/Tavchain/pkgs/container/tavchain-fullnode) includes the current network files; the [registry Compose file](https://github.com/safeney/Tavchain/blob/main/operators/docker/compose.registry.yaml) pins its exact digest. The [signed Docker archive](https://github.com/safeney/Tavchain/releases/tag/docker-771002-1) remains the local-build alternative. Verify `DOCKER-RELEASE.json` and its detached signature before extracting the archive and following its README. The original download base remains `https://testnet.tavchain.safeney.com/downloads/tavchain-docker-771002-1`. Both Docker routes map host RPC to `127.0.0.1` and publish no P2P host port. Their client is Linux amd64 only. The image digest identifies image bytes; it is separate from the archive's existing detached signature. Native binary compatibility is documented separately. ## Public peers ```text theme={null} 63c3e0f56b33ce0b45ebb03806dab3002691a187@77.42.64.182:28656 2b5612173d3d593a6cb210d436d7817ab9cb44b7@77.42.64.182:28756 b38fde60012b3fd37da07bdd82dce91428d50e73@77.42.64.182:28856 ``` These three endpoints share a hosting failure domain. They are persistent peers, not three independent operators or a separate seed service. The observer profile disables PEX and allows duplicate peer IPs. ## Local full-node listeners | Port | Purpose | Exposure | | - | - | - | | 29656 | CometBFT P2P | Loopback, with outbound peer connections | | 29657 | Native RPC | Loopback | | 29645 | EVM HTTP RPC | Loopback | | 29646 | EVM WebSocket | Local listener only | REST, gRPC, gRPC-web, metrics and unsafe RPC remain disabled. This observer follows history from genesis and retains it. It is not a validator configuration. See [Node service](/tavchain/operate/node-service), [Monitor a node](/tavchain/operate/monitoring) and [Security](/tavchain/learn/security). # Run a node with Docker Source: https://docs.tavchain.safeney.com/tavchain/operate/node-docker Run a Tavchain Testnet full node with Docker Compose, verify synchronization, and preserve its data and identity across normal stops and restarts. Run a Tavchain Testnet full node using the [prebuilt image](https://github.com/safeney/Tavchain/pkgs/container/tavchain-fullnode) and the configuration in [safeney/Tavchain](https://github.com/safeney/Tavchain/tree/main/operators/docker). The image includes the client and current network files. You do not need a wallet, stake or local image build. For Windows or Linux ARM64, use [native binaries](/tavchain/operate/node-native). For wallet or application access, use [public RPC](/tavchain/connect). ## Requirements Use Linux x86-64 with Git, Docker Engine, Compose v2, persistent SSD storage, reliable outbound internet and accurate time. Storage grows with chain history. Docker Desktop, WSL and ARM hosts are outside this image's tested platforms. Tavchain Testnet is unaudited; Test TAV has no monetary value. ## Start a full node Run these commands for a new node: ```bash theme={null} git clone --depth 1 https://github.com/safeney/Tavchain.git cd Tavchain/operators/docker docker compose -f compose.registry.yaml run --rm init docker compose -f compose.registry.yaml up -d node ``` Compose downloads the published image. The first command initializes a fresh node identity in persistent Docker storage; the second starts the node. Run initialization only once. If it fails, keep the volume and inspect the error before continuing. Never mount an existing validator home. The repository's [Compose file](https://github.com/safeney/Tavchain/blob/main/operators/docker/compose.registry.yaml) pins the accepted image by digest. Genesis and peer defaults are included, so you do not need to download or edit them separately. ## Check synchronization From the same directory: ```bash theme={null} docker compose -f compose.registry.yaml logs --tail 100 node ``` Wait for the node to catch up. To inspect native status: ```bash theme={null} curl --fail --silent --show-error http://127.0.0.1:29657/status ``` Expect network `tavchaintestnet_771002-1`, advancing block heights and `sync_info.catching_up: false` after synchronization. Zero voting power is normal for this non-validator node. For peer checks and fixed-height block comparisons, follow [Monitor a node](/tavchain/operate/monitoring). ## Stop and resume ```bash theme={null} docker compose -f compose.registry.yaml stop node docker compose -f compose.registry.yaml up -d node ``` Keep the same project and data volume. The node resumes its existing identity and history. Do not initialize again, remove its volume or start two processes against the same data. > [accordion] Local RPC and restart settings > > Host RPC mappings bind to `127.0.0.1`: native RPC `29657`, EVM HTTP `29645` and EVM WebSocket `29646`. No P2P host port is published; the node connects outbound to the configured peers. > > Compose uses `unless-stopped` while Docker is running. Host Docker startup is configured separately. The five-minute stop grace allows database shutdown after a stop request. > > Ordinary `docker compose -f compose.registry.yaml down` removes containers and the network while retaining data. Do not add `--volumes` or prune the node's volume. ## Other installation options The [signed Docker archive](https://github.com/safeney/Tavchain/releases/tag/docker-771002-1) remains available for local image builds. Follow its included README for that workflow; its `compose.yaml` differs from the prebuilt-image `compose.registry.yaml`. For direct executable installation, use [native binaries](/tavchain/operate/node-native). Read [Upgrades and recovery](/tavchain/operate/upgrades-recovery) before changing a retained node's client or image. Use [Troubleshooting](/tavchain/operate/troubleshooting) for startup and sync failures and [Network files and ports](/tavchain/operate/network-assets) for reference configuration. Contact [support@safeney.com](mailto:support@safeney.com) for help. # Run a native node Source: https://docs.tavchain.safeney.com/tavchain/operate/node-native Install a Tavchain Testnet full node on Linux x86-64, Linux ARM64 or Windows x86-64, verify the release, and check sync before using local RPC. Run a Tavchain Testnet full node directly on Linux or Windows. Download one bundle with the client, required libraries and testnet configuration included. You do not need a wallet or stake. For wallet or application access, use [public RPC](/tavchain/connect). ## Download Choose your platform from the [GitHub release](https://github.com/safeney/Tavchain/releases/tag/native-bundle-771002-1). | Platform | Download | | - | - | | Linux x86-64 | [Linux x64 bundle](https://github.com/safeney/Tavchain/releases/download/native-bundle-771002-1/tavchain-testnet-771002-linux-amd64.tar.gz) | | Linux ARM64 | [Linux ARM64 bundle](https://github.com/safeney/Tavchain/releases/download/native-bundle-771002-1/tavchain-testnet-771002-linux-arm64.tar.gz) | | Windows x86-64 | [Windows x64 ZIP](https://github.com/safeney/Tavchain/releases/download/native-bundle-771002-1/tavchain-testnet-771002-windows-amd64.zip) | Before running anything, follow [Verify the download](https://github.com/safeney/Tavchain/releases/download/native-bundle-771002-1/VERIFY.md) to check the release signature and your bundle's checksum. Use an ordinary user account, persistent SSD storage, reliable outbound internet and accurate system time. Keep RPC private and leave ports 29656, 29657, 29645 and 29646 free. Disk usage grows with chain history. ## Initialize and start Extract the bundle into a new folder and open a terminal in that folder. Keep all extracted files together. > [tab] Linux > > Initialize once, then start: > > ```bash theme={null} > ./tavchain-node init > ./tavchain-node start > ``` > [tab] Windows > > Open PowerShell in the extracted folder. Initialize once, then start: > > ```powershell theme={null} > .\tavchain-node.ps1 init > .\tavchain-node.ps1 start > ``` > > If Windows blocks the downloaded script, stop. After verifying the archive and reviewing the script, follow the release's [Windows file-blocking guidance](https://github.com/safeney/Tavchain/releases/download/native-bundle-771002-1/VERIFY.md#windows-file-blocking). Do not disable execution policy. Organization-managed restrictions may require your administrator. Initialization creates private node identities and stores node data in `.tavchain-testnet-771002` under your user directory. It refuses an existing home instead of overwriting it. If initialization fails, retain the partial directory and see [Troubleshooting](/tavchain/operate/troubleshooting). Keep the terminal open while the node runs. The included configuration selects native chain `tavchaintestnet_771002-1` and EVM chain `771002`, connects outbound to public peers and keeps RPC on loopback. ## Check synchronization Open `http://127.0.0.1:29657/status` in a browser. Check that `node_info.network` is `tavchaintestnet_771002-1`, block height advances and `sync_info.catching_up` becomes `false`. Zero voting power is normal for a full node. Initial sync replays history and can take time. For peer checks, local EVM RPC and reference-block comparisons, see [Monitor a node](/tavchain/operate/monitoring). ## Stop and restart Interrupt the node in its terminal and wait for shutdown before closing the window. Do not use Task Manager as the normal Windows shutdown procedure. Restart with the same `start` command and home. Do not initialize again, replace genesis, delete data or run two processes against one home. Custom absolute home paths are supported; see `./tavchain-node --help` on Linux or `.\tavchain-node.ps1 help` on Windows and supply the same home on every invocation. ## Compatibility The bundle uses client `1.8.1-tavchain.eval1-native1`. Non-validator initialization, sync, fixed-height state comparison and same-identity restart were tested on GitHub-hosted Ubuntu 24.04 x64/ARM64 and Windows Server 2022 x64. Linux graceful termination used SIGTERM; Windows used the console Ctrl+Break event. Windows browser-download file-blocking behavior was not part of that trial. These tests do not establish validator signing or long-duration reliability. Native macOS and Windows ARM64 bundles are unavailable. Test TAV has no monetary value. For background Linux x86-64 operation, use the [Docker guide](/tavchain/operate/node-docker). The [systemd guide](/tavchain/operate/node-service) covers a separate earlier client installation; do not mix its paths with this bundle. Find [source and release authentication files](https://github.com/safeney/Tavchain/releases/tag/native-bundle-771002-1) on GitHub. The [earlier native client release](https://github.com/safeney/Tavchain/releases/tag/native-1.8.1-tavchain.eval1-native1) remains available. For configuration and ports, see [Network files and ports](/tavchain/operate/network-assets). Contact [support@safeney.com](mailto:support@safeney.com) for help. # Node roles and access Source: https://docs.tavchain.safeney.com/tavchain/operate/node-roles Choose the right interface and understand validator participation. Choose the interface that matches your task. Using Tavchain from a wallet or application does not require running a node. | Role | Purpose | Current access | | - | - | - | | Wallet or application | Sign transactions locally and use chain data | Public HTTP Ethereum JSON-RPC. | | Full node | Follow and verify the chain; serve a local RPC | Public genesis sync using the [full-node release](/tavchain/operate). | | Validator | Vote in consensus and sign block commits | Native registration and bonded stake determine active membership; initial operators remain centrally controlled. | | Explorer | Browse indexed blocks, transactions, contracts and tokens | [Tavchain explorer](https://explorer.tavchain.safeney.com/). | ## Full nodes and validators An unregistered full node normally has zero consensus voting power. It can verify history and answer local queries without a staking deposit or wallet keyring. A funded account and a network ID do not automatically provide consensus power. The native staking module supports validator registration and delegation, with up to 10 active validators selected by bonded stake. See [staking](/tavchain/learn/staking) and [governance](/tavchain/learn/governance). Never copy a running validator's consensus key or signer state into another node. The public installation guides create a separate non-validator identity and home. ## Public and local interfaces Use the [public EVM HTTP endpoint](/tavchain/http-api) for applications. The packaged full-node profile binds its own listeners to loopback. Debug tracing and public WebSocket access are not offered as public services. An RPC error or explorer delay is not, by itself, proof that consensus has stopped. Check [Troubleshooting](/tavchain/troubleshooting) or [node monitoring](/tavchain/operate/monitoring). [Connect a wallet](/tavchain/connect) · [Install a full node](/tavchain/operate) # Run a node as a service Source: https://docs.tavchain.safeney.com/tavchain/operate/node-service Keep a Tavchain full node running with systemd, persistent state and standard Linux commands. Use systemd to run a non-validator full node in the background. This guide uses client `1.8.1-tavchain.eval1` from the [earlier Linux installation](/tavchain/operate/run-full-node), not the newer native bundle. No wallet, faucet claim, staking deposit or keyring passphrase is needed. > [!NOTE] > > For a new installation, start with the [installation chooser](/tavchain/operate). Docker provides the current packaged background workflow on Linux x86-64. The unit and paths below belong only to this earlier native installation; do not substitute a new bundle or point them at its home without a matching service procedure. ## Before you start Complete the signature, fingerprint, archive and internal checksum checks in [Run a full node](/tavchain/operate/run-full-node). Start in the extracted `tavchain-node` directory after replacing its historical network files with the separately authenticated 771002 network package from that guide. You need a compatible Linux x86-64 host, systemd, sudo access and the prerequisites from that guide. The reference platform is Ubuntu 24.04 with systemd 255. This procedure creates a **fresh service account and home**. Do not use it to overwrite a validator, migrate an existing node or modify a shared Tavchain installation. If you have a foreground node using ports 29656/29657/29645/29646, stop it gracefully first. Leave its home intact; this new service starts its own history sync. Check those ports are free before continuing. The network is unaudited and centrally operated. Test TAV has no monetary value. ## Install the binary and account These commands stop on an existing binary path, account, state home or unit. Review any existing installation instead of overwriting it. ```bash theme={null} set -e TAVCHAIN_BINARY=/opt/tavchain-evm/releases/1.8.1-tavchain.eval1/bin/tavchaind sudo test ! -e "$TAVCHAIN_BINARY" sudo test ! -e /var/lib/tavchain-fullnode sudo test ! -e /etc/systemd/system/tavchain-fullnode.service if getent passwd tavchain-fullnode >/dev/null || getent group tavchain-fullnode >/dev/null; then echo 'Existing service account/group: inspect before continuing' exit 1 fi sudo install -D -m 0555 -o root -g root bin/tavchaind "$TAVCHAIN_BINARY" sudo useradd --system --user-group --no-create-home --home-dir /var/lib/tavchain-fullnode --shell /usr/sbin/nologin tavchain-fullnode sudo install -d -m 0700 -o tavchain-fullnode -g tavchain-fullnode /var/lib/tavchain-fullnode ``` The service runs as `tavchain-fullnode`, not root. The versioned binary is root-owned; only the node home is writable by the service account. No operational validator or wallet keys are copied. ## Initialize the fresh service home Run initialization once, as the service account. Native initialization creates private P2P and unused consensus identity files. Keep them private. The account is not registered as a validator. ```bash theme={null} sudo -u tavchain-fullnode /opt/tavchain-evm/releases/1.8.1-tavchain.eval1/bin/tavchaind init my-tavchain-fullnode --chain-id tavchaintestnet_771002-1 --default-denom atav --home /var/lib/tavchain-fullnode for file in genesis.json config.toml app.toml; do sudo install -m 0600 -o tavchain-fullnode -g tavchain-fullnode "network/$file" "/var/lib/tavchain-fullnode/config/$file" done ``` The configuration retains full history, connects outbound to the published peers and binds listeners to loopback. No public RPC or firewall opening is required. [Network files and ports](/tavchain/operate/network-assets) lists the exact configuration. ## Create the service Save the complete unit below. It runs the native client directly; no launcher script or upgrade manager is required. ```bash theme={null} cat > tavchain-fullnode.service <<'EOF' [Unit] Description=Tavchain Testnet non-validator full node Wants=network-online.target After=network-online.target StartLimitIntervalSec=120 StartLimitBurst=5 [Service] Type=exec User=tavchain-fullnode Group=tavchain-fullnode WorkingDirectory=/var/lib/tavchain-fullnode Environment=HOME=/var/lib/tavchain-fullnode ExecStart=/opt/tavchain-evm/releases/1.8.1-tavchain.eval1/bin/tavchaind start --home /var/lib/tavchain-fullnode --moniker my-tavchain-fullnode --genesis_hash a101ab9ccf1478757af8a69d832548ea1167e552fe6d6ef6621a77447a54e924 Restart=on-failure RestartSec=5 KillSignal=SIGTERM KillMode=control-group TimeoutStopSec=infinity UMask=0077 NoNewPrivileges=true PrivateTmp=true ProtectSystem=strict ProtectHome=true ReadWritePaths=/var/lib/tavchain-fullnode [Install] WantedBy=multi-user.target EOF sudo install -m 0644 -o root -g root tavchain-fullnode.service /etc/systemd/system/tavchain-fullnode.service sudo systemd-analyze verify /etc/systemd/system/tavchain-fullnode.service sudo systemctl daemon-reload sudo systemctl start tavchain-fullnode.service ``` Change `--moniker my-tavchain-fullnode` in your unit if you want another public node label. Keep the home, binary version and genesis pin consistent with this release. ## Check status and sync ```bash theme={null} sudo systemctl status tavchain-fullnode.service sudo journalctl -u tavchain-fullnode.service -f ``` Press Ctrl+C to stop following logs; that does not stop the service. `active (running)` means the process started, not that it is synced. Check the node separately: ```bash theme={null} set -e curl --fail --silent --show-error http://127.0.0.1:29657/status | python3 -m json.tool curl --fail --silent --show-error http://127.0.0.1:29657/net_info | python3 -m json.tool curl --fail --silent --show-error http://127.0.0.1:29645/ -H 'Content-Type: application/json' --data '{"jsonrpc":"2.0","id":1,"method":"eth_chainId","params":[]}' ``` Expect native network `tavchaintestnet_771002-1`, advancing block height, at least one peer, `catching_up: false` after sync and EVM chain ID `0xbc3ba` (771002). A non-validator full node normally has zero voting power. Compare a block hash at a fixed common height with the public RPC when checking agreement. Use [Monitor a node](/tavchain/operate/monitoring) for a complete fixed-height comparison and ongoing host checks. For startup failures, missing peers or restart loops, follow [Troubleshoot a node](/tavchain/operate/troubleshooting). ## Stop and restart ```bash theme={null} sudo systemctl stop tavchain-fullnode.service sudo systemctl start tavchain-fullnode.service ``` Use `sudo systemctl restart tavchain-fullnode.service` to perform both in sequence. Keep the same home; do not initialize again, replace genesis or delete data between starts. Stopping sends SIGTERM and waits for graceful shutdown. The unit does not force-kill a slow database shutdown. If stop remains pending, inspect the journal, process and disk before taking recovery action; do not start another process on the same home. An unexpected process failure triggers a restart after 5 seconds. Five starts within 120 seconds trigger systemd's crash-loop protection. This controls crash-loop retries. After diagnosing and fixing the cause, use `sudo systemctl reset-failed tavchain-fullnode.service`, then start normally. An explicit stop does not trigger automatic restart. ## Optional start after boot ```bash theme={null} sudo systemctl enable tavchain-fullnode.service sudo systemctl is-enabled tavchain-fullnode.service ``` To remove boot startup, use `sudo systemctl disable tavchain-fullnode.service`. Disabling alone does not stop an active service. After a host reboot, check service status, peers and sync before using the local RPC. Enabling a unit does not replace those readiness checks. ## Operational checks For planned maintenance, client changes and interruption recovery, follow [Upgrades and recovery](/tavchain/operate/upgrades-recovery). Keep the same node home across ordinary restarts. Keep the node home and identity across starts. Monitor block progress, peer connectivity, free disk space and inodes. The service running successfully is only the first step; use [Monitor a node](/tavchain/operate/monitoring) to check readiness. For failed starts or repeated restarts, follow [Troubleshoot a node](/tavchain/operate/troubleshooting). Do not reset the home or copy validator state as a routine repair. # Run a full node Source: https://docs.tavchain.safeney.com/tavchain/operate/run-full-node Follow Tavchain Testnet from genesis with the native node client. Run a non-validator full node to verify the chain and query your own local RPC. No wallet, faucet claim, staking deposit or account passphrase is needed to follow the network. Validator registration is separate; this guide does not enroll a validator. > [!NOTE] > > This is the earlier Linux x86-64 installation for client `1.8.1-tavchain.eval1`, retained for its matching [systemd guide](/tavchain/operate/node-service). For a new node, choose [Docker or a native bundle](/tavchain/operate); both include the current network configuration. You do not need to follow this manual procedure for those packages. Wallets and applications can use [public RPC](/tavchain/connect) without installing a node. For Linux ARM64 and Windows x86-64 binaries, or the newer statically linked Linux x86-64 build, follow [Run a native node](/tavchain/operate/node-native). The instructions below retain the earlier Linux x86-64 client release. ## Before you start Use a dedicated Linux x86-64 host or user account. This binary requires a compatible glibc loader and references symbols through glibc 2.34. This earlier archive is Linux x86-64 only; other tested native targets are listed in [Run a native node](/tavchain/operate/node-native). Wallets and applications can use public RPC without running a node. You need persistent SSD storage, reliable outbound internet, accurate system time, curl, tar, sha256sum and Python3 for readable JSON. The tested profile retains full history, so disk use grows with the chain. Leave free disk and inode headroom and monitor growth. Hardware requirements depend on workload; no measured general capacity minimum is published for this release. The network is unaudited and centrally operated. Test TAV has no monetary value. ## Download and verify the release Download into a fresh directory. You need OpenSSH with `ssh-keygen -Y verify`. Stop if any verification command fails. ```bash theme={null} set -e mkdir tavchain-node-download cd tavchain-node-download export TAVCHAIN_RELEASE_URL=https://testnet.tavchain.safeney.com/downloads/tavchain-node-1.8.1-tavchain.eval1 curl --fail --location --remote-name "$TAVCHAIN_RELEASE_URL/RELEASE.json" curl --fail --location --remote-name "$TAVCHAIN_RELEASE_URL/RELEASE.json.sig" curl --fail --location --remote-name "$TAVCHAIN_RELEASE_URL/release1_ed25519.pub" awk 'NR==1 {print $1 " " $2}' release1_ed25519.pub > trusted-release.pub test "$(ssh-keygen -lf trusted-release.pub | awk '{print $2}')" = 'SHA256:rZRDFiztp0bd51gCAI/qKBGxkOKl9Fv52UWdbUpUQRM' printf 'safeney-tavchain-releases namespaces="tavchain-release-v1" %s\n' "$(cat trusted-release.pub)" > local-allowed-signers ssh-keygen -Y verify -f local-allowed-signers -I safeney-tavchain-releases -n tavchain-release-v1 -s RELEASE.json.sig < RELEASE.json ``` ```bash theme={null} set -e curl --fail --location --remote-name "$TAVCHAIN_RELEASE_URL/tavchain-node-1.8.1-tavchain.eval1-linux-amd64.tar.gz" python3 -c 'import json; m=json.load(open("RELEASE.json")); n="tavchain-node-1.8.1-tavchain.eval1-linux-amd64.tar.gz"; print(m["files"][n]["sha256"]+" "+n)' | sha256sum --check ``` ```bash theme={null} set -e tar -xzf tavchain-node-1.8.1-tavchain.eval1-linux-amd64.tar.gz cd tavchain-node sha256sum --check SHA256SUMS ./bin/tavchaind version --long ``` The fingerprint must match your trusted Tavchain release-key record. The local signer list uses that checked key, not a blindly trusted download. The signed manifest authenticates the archive hash; internal checksums check extracted files. The 50.84 MB node bundle is sufficient to run; [source/dependency downloads](/tavchain/operate/network-assets) are separate. ## Select the new network files The unchanged client archive also contains historical network files. Before initialization, download and verify the separate [771002 network package](/tavchain/operate/network-assets) using its signed `NETWORK-RELEASE.json` and the same trusted release-key fingerprint. Do not use the archive's old embedded genesis. After all network-package signatures and hashes pass, from the extracted `tavchain-node` directory: ```bash theme={null} set -e mkdir network-771002 cd network-771002 export TAVCHAIN_NETWORK_URL=https://testnet.tavchain.safeney.com/downloads/tavchain-network-771002-1 for file in genesis.json config.toml app.toml peers.txt network.json README.md VERIFY.md SHA256SUMS tavchain-network-771002-1.tar.gz NETWORK-RELEASE.json NETWORK-RELEASE.json.sig release1_ed25519.pub; do curl --fail --location --remote-name "$TAVCHAIN_NETWORK_URL/$file" done awk 'NR==1 {print $1 " " $2}' release1_ed25519.pub > trusted-release.pub test "$(ssh-keygen -lf trusted-release.pub | awk '{print $2}')" = 'SHA256:rZRDFiztp0bd51gCAI/qKBGxkOKl9Fv52UWdbUpUQRM' printf 'safeney-tavchain-releases namespaces="tavchain-release-v1" %s\n' "$(cat trusted-release.pub)" > local-allowed-signers ssh-keygen -Y verify -f local-allowed-signers -I safeney-tavchain-releases -n tavchain-release-v1 -s NETWORK-RELEASE.json.sig < NETWORK-RELEASE.json python3 -c 'import json; m=json.load(open("NETWORK-RELEASE.json")); print("\n".join(v["sha256"]+" "+k for k,v in m["files"].items()))' | sha256sum --check cd .. cp network-771002/genesis.json network-771002/config.toml network-771002/app.toml network/ ``` If a download is unavailable or verification fails, stop; do not fall back to a predecessor genesis. The final genesis hash must be `a101ab9ccf1478757af8a69d832548ea1167e552fe6d6ef6621a77447a54e924`. ## Initialize a fresh node Use a fresh directory, never a production validator home. Run as an ordinary user. The native init command creates a private P2P identity and an unused consensus key. Keep those files private; do not copy validator keys or reuse a validator's signer state. ```bash theme={null} umask 077 export TAVCHAIN_NODE_HOME="$HOME/.tavchain-testnet-fullnode" test ! -e "$TAVCHAIN_NODE_HOME" || { echo 'Choose a fresh node directory'; exit 1; } ./bin/tavchaind init my-tavchain-node --chain-id tavchaintestnet_771002-1 --default-denom atav --home "$TAVCHAIN_NODE_HOME" cp network/genesis.json network/config.toml network/app.toml "$TAVCHAIN_NODE_HOME/config/" ``` The start command sets your public node label with `--moniker`. The package contains network configuration, not private keys or existing ledger state. ## Start and sync Check that ports 29656/29657/29645/29646 are unused before starting. All listeners bind to 127.0.0.1; the node connects outbound to the listed public peers. No firewall opening or public RPC is required for this guide. ```bash theme={null} ./bin/tavchaind start --home "$TAVCHAIN_NODE_HOME" --moniker my-tavchain-node --genesis_hash a101ab9ccf1478757af8a69d832548ea1167e552fe6d6ef6621a77447a54e924 ``` Keep this terminal open. In a second terminal, check native status and peers: ```bash theme={null} set -e curl --fail --silent --show-error http://127.0.0.1:29657/status | python3 -m json.tool curl --fail --silent --show-error http://127.0.0.1:29657/net_info | python3 -m json.tool ``` Expect native network tavchaintestnet\_771002-1, advancing height and at least one peer. When caught up, sync\_info.catching\_up becomes false. Your full node's validator\_info.voting\_power should be 0: that is normal for an unregistered observer. An existing registered validator with zero voting power needs a different diagnosis. Check the local EVM chain ID: ```bash theme={null} set -e curl --fail --silent --show-error http://127.0.0.1:29645/ -H 'Content-Type: application/json' --data '{"jsonrpc":"2.0","id":1,"method":"eth_chainId","params":[]}' ``` Expect 0xbc3ba (771002). Compare a block hash at one fixed height through your local RPC and the public RPC; comparing two moving latest heights is inconclusive. See [Monitor a node](/tavchain/operate/monitoring#compare-a-fixed-block) for the complete read-only comparison. ## Stop and restart Press Ctrl+C in the node terminal and wait for shutdown before starting it again. Use the same home and start command. The node should resume retained state and catch up; do not run init again, replace its genesis or delete its data. To run the node in the background, follow [Run a node as a service](/tavchain/operate/node-service). The service guide describes background operation, graceful shutdown and restart behavior. ## If it does not sync Follow [Troubleshoot a node](/tavchain/operate/troubleshooting) for startup, peer, RPC and storage symptoms, and [Monitor a node](/tavchain/operate/monitoring) for continuing readiness checks. Check the selected release/genesis, local port conflicts, outbound peer connectivity, clock and available disk/inodes. A disconnected or catching-up node is not ready for application use. Keep native/EVM RPC on loopback. Do not use reset, pruning, snapshot replacement or validator-key copying as a first response. # Troubleshoot a node Source: https://docs.tavchain.safeney.com/tavchain/operate/troubleshooting Diagnose startup, peer, sync and RPC problems without resetting node state. Start with the symptom, collect a small amount of evidence and correct the identified cause. This guide is for the released **non-validator full node**. Validator signing, jailing and key recovery are separate procedures. Use [Monitor a node](/tavchain/operate/monitoring) for status and fixed-height comparisons. Local RPC checks use the [published ports](/tavchain/operate/network-assets). The `systemctl`, journal and `/var/lib/tavchain-fullnode` examples below apply only to the [earlier systemd installation](/tavchain/operate/node-service). For Docker, inspect the container and logs using the [Docker guide](/tavchain/operate/node-docker). For a native bundle, inspect output in its running terminal and use the same home selected by its [launcher](/tavchain/operate/node-native). Neither installation creates `tavchain-fullnode.service`. ## Service will not start ```bash theme={null} sudo systemctl status tavchain-fullnode.service --no-pager sudo systemctl show tavchain-fullnode.service --property=Result,ExecMainCode,ExecMainStatus,NRestarts sudo journalctl -u tavchain-fullnode.service -n 100 --no-pager ``` Read the first relevant startup error, rather than treating the final process exit as the cause. | Symptom | Check next | | - | - | | Binary missing or not executable | Verify the unit's versioned `ExecStart` path and the release checksum/signature checks in the installation guide | | Permission denied | Verify ownership of the chosen home and access for the service account; do not make private directories or keys world-readable | | Address already in use | Find the process using the expected port; do not start a second node against the same home | | Wrong genesis/network or genesis hash error | Compare the installed release and genesis with the authenticated network files; preserve the existing home for investigation | | Database or I/O error | Check storage availability and the filesystem; preserve state and obtain help before attempting repair | The published service runs as `tavchain-fullnode` and writes only its own home. Running it as root or loosening all permissions is not a diagnosis. ## Local RPC refuses the connection Confirm that the node is running and inspect the loopback listeners: ```bash theme={null} sudo ss -ltnp '( sport = :29656 or sport = :29657 or sport = :29645 or sport = :29646 )' ``` The packaged profile uses native RPC `127.0.0.1:29657` and EVM HTTP `127.0.0.1:29645`. A request to another host, a production-validator port or the wrong interface will not test this node. A container's `127.0.0.1` refers to that container, not its host. A timeout is different from a refusal: inspect the endpoint, logs and host load before assuming the chain has stopped. Keep the listeners on loopback; opening a firewall or binding RPC to every interface is not needed to diagnose local access. ## No peers or stalled sync Check `/net_info` and `/status` using the [monitoring commands](/tavchain/operate/monitoring#check-network-and-sync). Inspect the peer errors in the journal, then compare the selected release's persistent peers with [Network files and ports](/tavchain/operate/network-assets). The accepted full-node profile connects **outbound** to the three published cloud peer endpoints. It needs no incoming firewall opening for this workflow. Verify outbound connectivity to their advertised host and ports. Those three peers share one cloud host; they do not provide three independent hosting failure domains. Check accurate host time and available disk/inodes. During initial genesis sync, height should advance toward the network tip; it need not be caught up immediately. If the public reference progresses while your node remains at one height, investigate local peers, logs and host resources. If both stop, reference failure or a network incident is also possible; do not infer the cause from one endpoint. ## Process active but node behind `active (running)` confirms that the process exists, not that it is ready for applications. Check height over time, peer connectivity and `catching_up`, then compare a fixed common block with the public reference. A matching block far behind the tip proves agreement only at that old height. A different hash at the same height needs investigation. Keep the home intact; do not replace genesis or delete the database to silence a mismatch. ## Repeated automatic restarts The published unit retries unexpected failures after five seconds. Five starts within 120 seconds trigger systemd's crash-loop protection. Find and fix the underlying error before clearing the failed state using the [service lifecycle commands](/tavchain/operate/node-service#stop-and-restart). Do not increase retry limits to hide the error. An explicit `systemctl stop` does not request an automatic restart. If graceful stop remains pending, inspect the journal, process and storage; do not launch another process on that home or force-kill it as a routine fix. ## Disk or inodes running low ```bash theme={null} sudo df -h /var/lib/tavchain-fullnode sudo df -i /var/lib/tavchain-fullnode ``` Check the filesystem holding your actual node home. Full history grows over time. Plan additional storage or a reviewed maintenance procedure before exhausting it. This guide does not prescribe deletion of block data, recovery logs, signer state or key files, and does not provide a pruning/reset/snapshot-replacement procedure. ## RPC errors and pending transactions An HTTP 200 response may contain a JSON-RPC `error`. Confirm EVM chain ID `771002`, use the EVM HTTP endpoint for `eth_*` requests, and read the returned code/message. The public RPC can return HTTP 429 under load; slow down and retry read requests later. If a submitted transaction's result is unclear, look up its existing hash in the [explorer](https://explorer.tavchain.safeney.com/) or RPC before submitting anything again. A receipt with status `0x0` means execution failed; inspect that transaction rather than assuming another submission will fix it. Do not give anyone a wallet password, seed phrase or private key to diagnose an RPC problem. ## Maintenance and upgrade recovery Use [Upgrades and recovery](/tavchain/operate/upgrades-recovery) for same-version restart and catch-up checks. Software changes need the target release's compatibility and migration instructions; an older binary may not be able to read a database changed by a newer release. ## Get help with safe diagnostics Contact [support@safeney.com](mailto:support@safeney.com) with the client version, operating system, approximate UTC time, symptom, relevant error lines, height/peer count and any **public** transaction hash. Explain which steps you already checked. Review and redact diagnostics before sharing: logs and configuration can include private addresses, credentials or other sensitive information. Never send an entire node home, keyring, consensus key, P2P private key, signer state, private environment file or wallet secret. Support is best effort, with no guaranteed response time. Use release-specific instructions for upgrades or state repair. Validator recovery differs from full-node troubleshooting; do not copy signing keys or apply unjailing commands to a non-validator node. # Upgrades and recovery Source: https://docs.tavchain.safeney.com/tavchain/operate/upgrades-recovery Maintain an existing full node, prepare for client upgrades and recover from interruptions. Preserve your full node's existing home and use the maintenance procedure for its installation method. The commands below apply to the earlier non-validator [systemd installation](/tavchain/operate/node-service). Validator signing and key recovery require a separate procedure. ## Identify your installation | Installation | Routine lifecycle instructions | | - | - | | Prebuilt Docker image | Use the stop/start commands in [Run a node with Docker](/tavchain/operate/node-docker) and retain its named volume. | | Native bundle | Use the same launcher and home from [Run a native node](/tavchain/operate/node-native#stop-and-restart). Do not initialize again. | | Earlier Linux systemd installation | Follow the service commands on this page. Its binary and home paths do not apply to the native bundle. | These are restart instructions, not permission to exchange clients or migrate databases. Downloading a newer package does not upgrade an existing node or establish database compatibility. ## Check your version This systemd guide uses **1.8.1-tavchain.eval1**, for native network `tavchaintestnet_771002-1` and EVM chain ID `771002`. Other installation methods have separate client releases; see [Release status](/tavchain/status) for current compatibility. For the published service installation: ```bash theme={null} /opt/tavchain-evm/releases/1.8.1-tavchain.eval1/bin/tavchaind version --long sudo systemctl show tavchain-fullnode.service --property=ExecStart,ActiveState,SubState ``` The version command describes that binary. Check that the service's `ExecStart` selects the same path; an old running process does not change versions just because another binary has been downloaded. ## Choose the right action | Situation | Action | | - | - | | Routine maintenance, same client and healthy storage | Stop gracefully, then start the same service and home | | Unexpected process exit | Inspect the journal and allow the configured restart behavior to work | | Host reboot or a longer interruption | Start the existing service if needed, then check peers and catch-up | | A new Tavchain release is announced | Follow its exact version, compatibility and activation instructions | | Database errors, wrong genesis or conflicting block hashes | Preserve the home and investigate before changing software or data | A restart does not require initialization, a new genesis, a wallet or a faucet claim. ## Stop and resume safely For planned maintenance: ```bash theme={null} sudo systemctl stop tavchain-fullnode.service sudo systemctl show tavchain-fullnode.service --property=ActiveState,SubState ``` Wait until the service is inactive before continuing maintenance. The service sends SIGTERM and waits for graceful shutdown. If stopping remains pending, inspect the journal and host storage; do not start a second process against the same home. Resume the same installation: ```bash theme={null} sudo systemctl start tavchain-fullnode.service sudo systemctl status tavchain-fullnode.service --no-pager sudo journalctl -u tavchain-fullnode.service -n 100 --no-pager ``` Use the [monitoring checks](/tavchain/operate/monitoring#check-network-and-sync) to confirm the network identity, peers, advancing height and completed catch-up. Then [compare a fixed block](/tavchain/operate/monitoring#compare-a-fixed-block) with the public reference. Process status alone is not readiness. ## Recover after an interruption The service retains its node identity and database. After an unexpected exit, systemd retries after five seconds; repeated failures can trigger its start-rate limit. An explicit stop does not trigger automatic restart. 1. Inspect the service result and the first relevant journal error. 2. Check available disk space, inodes, host time and outbound peer connectivity using [Troubleshoot a node](/tavchain/operate/troubleshooting). 3. Correct the identified cause while retaining the existing home. 4. Start the service and verify catch-up and block agreement. Only after correcting a failure that triggered systemd's start-rate limit, clear the failed state and start again: ```bash theme={null} sudo systemctl reset-failed tavchain-fullnode.service sudo systemctl start tavchain-fullnode.service ``` After a reboot, an enabled unit should start through systemd. Check its actual state and readiness; see [boot startup](/tavchain/operate/node-service#optional-start-after-boot) for configuration. If the database cannot reopen, preserve it and contact support rather than repeating restarts or running a reset. ## Prepare for a software upgrade A routine restart and a protocol upgrade are different operations. A protocol upgrade may require a specific client at a specific block height; incompatible clients may stop following the network. Before changing versions, read the Tavchain release notice and confirm: * The exact target release and supported source version. * Authenticated downloads, checksums and the required platform. * Any activation height or time and when operators must switch. * Configuration changes and compatibility with the existing database. * Post-upgrade checks and a release-specific recovery procedure. Verify downloads using the [release authentication procedure](/tavchain/operate/run-full-node#download-and-verify-the-release) and the target release's own manifest. Stage the new binary separately from the running executable. Keep the existing home; change the service's binary path only as directed by that release. Use Tavchain's release-specific instructions. Other networks' binaries and upgrade procedures are not interchangeable with Tavchain's network identity, genesis and application configuration. The published service starts the client directly; an automatic upgrade manager is not included. A newer binary may migrate persistent data. Returning to the old executable is not necessarily a safe rollback after it has written to the database. Follow that release's recovery instructions instead of assuming a binary downgrade will work. ## State repair and help Keep the node home intact during investigation. Do not delete block data, replace genesis, import an unrelated snapshot or copy another node's keys as a routine repair. Full-node state repair and validator signer recovery have different requirements. For assistance, use [Report an issue](/tavchain/contribute/reporting) or email [support@safeney.com](mailto:support@safeney.com). Share the client version, operating system, approximate UTC time, symptom and redacted error lines. Never send an entire node home, credentials, private keys or signer state. Check [network availability](https://status.tavchain.safeney.com/) alongside local diagnostics. A hosted status page is useful context, not proof that your own full node is ready. # Release status Source: https://docs.tavchain.safeney.com/tavchain/status Check Tavchain Testnet's available interfaces, published node release, compiler compatibility and current limits on participation and public services. Tavchain Testnet is an EVM network for application development. Public services use EVM chain ID 771002 and native chain ID tavchaintestnet\_771002-1. This page describes release capabilities and compatibility; it is not a real-time uptime monitor. ## Interfaces | Area | Available workflow | | - | - | | Wallets | Custom EVM network connection, with MetaMask as the reference wallet. | | Transactions | Native Test TAV transfers and Solidity contract deployment and interaction. | | Developer tools | Browser development with Remix and a [Hardhat 3 starter](/tavchain/hardhat) with a verified public GLD deployment and token-transfer example on chain 771002. | | Explorer | Blocks, transactions, token activity and contract-source verification through Blockscout. | | Faucet | 1 Test TAV per address per 24 hours, subject to challenge verification and available balance. | | RPC | Public HTTP Ethereum JSON-RPC with the [documented limits](/tavchain/http-api). | | Nodes | [Native full-node downloads](/tavchain/operate/node-native) for Linux x86-64, Linux ARM64 and Windows x86-64, plus separate [Docker](/tavchain/operate/node-docker) and [Linux service](/tavchain/operate/node-service) guides. | ## Release compatibility Operators should use [Upgrades and recovery](/tavchain/operate/upgrades-recovery) for maintenance and release-specific upgrade guidance. For current hosted service availability, see [Tavchain Status](https://status.tavchain.safeney.com/). The [prebuilt Docker image](/tavchain/operate/node-docker) uses **1.8.1-tavchain.eval1** on Linux x86-64 and includes the 771002 network configuration. It passed fresh non-validator sync, fixed-height state comparisons and same-identity graceful restart on GitHub-hosted Ubuntu 24.04. The [Linux service guide](/tavchain/operate/node-service) uses the same client version through a separate native installation and targets Ubuntu 24.04 with systemd 255. The **1.8.1-tavchain.eval1-native1** release provides native full-node downloads for Linux x86-64, Linux ARM64 and Windows x86-64. Its checks cover non-validator sync, state comparison, graceful shutdown and restart on the [documented test environments](/tavchain/operate/node-native). They do not establish validator operation for these binaries. Native macOS and Windows ARM64 downloads are not available. Wallets and applications do not need to run a node to use public RPC. The contract tutorials use Solidity 0.8.21 with the Shanghai EVM target. Use the exact settings in each guide when reproducing its build or verifying source. Other compiler and tool combinations need their own compatibility checks. ## Current limitations * The testnet is unaudited and uses an initial validator set under shared administration. * The network uses native TAV staking, delegation, fee distribution and governance. Its initial validators remain centrally operated; independent operator acceptance is pending. * No official bridge, IBC asset-transfer route or mainnet balance conversion is available. * Public WebSocket RPC and debug tracing are not offered. * Availability is best effort. No uptime SLA or guaranteed incident response time is offered. Test TAV is for development and has no monetary value. Read the [security model](/tavchain/learn/security) before using the network. ## Get started or get help [Developer quickstart](/tavchain/getting-started) · [Node installation](/tavchain/operate) · [Troubleshooting](/tavchain/troubleshooting) · [Contact support](/tavchain/contribute/reporting) # Start testing Tavchain Source: https://docs.tavchain.safeney.com/tavchain/testnet Start testing Tavchain with wallet setup, faucet funding, transfers and Solidity development, using the public testnet interfaces. Use Tavchain Testnet to develop transfers and Solidity applications with valueless Test TAV. You can use the public endpoints without running a node. > [!NOTE] > > This testnet uses EVM chain ID 771002. Balances, account nonces and contracts from the previous 771001 networks are not carried forward. Select the new wallet network and request fresh Test TAV from the faucet. ## Start testing 1. [Connect an EVM wallet](/tavchain/connect) to chain ID **771002**. 2. [Request Test TAV](/tavchain/faucet) from the faucet. 3. [Send a small transfer](/tavchain/first-transfer) and check its receipt. 4. [Deploy a contract](/tavchain/contracts) with Remix or Hardhat. 5. Inspect transactions and contract source in the [explorer](https://explorer.tavchain.safeney.com/). ## Choose an interface Use [Ethereum JSON-RPC](/tavchain/http-api) for application queries and transaction submission. To verify chain history locally, follow [Run a full node](/tavchain/operate). ## Testnet expectations The network is unaudited, with initial validators under shared administration. Availability is best effort. Native staking, delegation, fee distribution and governance are configured for the testnet; official bridges are unavailable, and no test-balance conversion to mainnet is announced. [Network information](/tavchain/network) · [Release information](/tavchain/status) · [Troubleshooting](/tavchain/troubleshooting) # Transactions Source: https://docs.tavchain.safeney.com/tavchain/transactions Choose the correct Tavchain interface for native transfers, contract transactions, read-only calls and execution-result checks. Use Tavchain's Ethereum-compatible transaction interface to transfer Test TAV, deploy contracts or call state-changing methods. Sign locally for chain ID **771002**, then submit signed bytes through RPC. ## Choose the operation | Task | Interface | | - | - | | Send Test TAV | Wallet transfer or locally signed value transaction. | | Deploy or update a contract | Signed EVM transaction with gas. | | Read contract state | `eth_call`, without a transaction submission. | | Inspect execution | `eth_getTransactionReceipt` using the transaction hash. | ## Manage submission Your wallet or signing library manages nonce, gas and fee fields. A returned transaction hash identifies the submission; it does not prove execution succeeded. If the response is unclear, inspect the original hash before making a replacement. [Send a transfer](/tavchain/first-transfer) · [Transaction lifecycle](/tavchain/learn/transactions) · [Submit signed bytes](/tavchain/api/submit-transaction) · [Read a receipt](/tavchain/api/transaction) # Wallet and RPC troubleshooting Source: https://docs.tavchain.safeney.com/tavchain/troubleshooting Resolve common Tavchain wallet, faucet, RPC and transaction problems, including network selection, rate limits and uncertain submissions. Use these checks when connecting a wallet, requesting Test TAV or submitting a transaction. Retain the original transaction hash whenever a submission result is unclear. ## Common problems | Symptom | What to check | | - | - | | RPC returns HTTP 503 | Service availability and endpoint URL; try a read request later. | | Balance looks wrong | Selected chain ID **771002** and the intended account. | | Wallet cannot add the network | Exact [network settings](/tavchain/network), RPC availability and browser profile where the wallet is installed. | | Faucet challenge fails | Complete the challenge normally. Never provide keys or pay for test tokens. | | Faucet cooldown | Allow 24 hours for the recipient address; inspect the existing claim/hash. | | RPC returns HTTP 429 | Back off. Users behind the same public IP share the quota. | | Submission times out | Look up the original transaction hash and account nonce before replacing it. | | Receipt status is `0x0` | Execution failed; inspect the contract error and gas behavior. | | Explorer does not list the transaction | Check the RPC receipt and allow time for indexing. | ## Get help Email [support@safeney.com](mailto:support@safeney.com) with the tool version, network, exact error, reproduction steps and public transaction hash. Use [Report an issue](/tavchain/contribute/reporting) for a checklist. Never send seed phrases, private keys, passwords or CAPTCHA secrets. Debug tracing is not a public service; do not expose a private node endpoint to work around it. For a node startup or sync problem, use [Troubleshoot a node](/tavchain/operate/troubleshooting). # Verify a contract Source: https://docs.tavchain.safeney.com/tavchain/verify-contract Publish your Solidity source on Tavchain Testnet's explorer, match the original compiler settings, and read your verified contract without a wallet. Verify your deployed Tavchain contract so developers can inspect its source and use the explorer's **Read/Write contract** interface. Verification checks that compiled source corresponds to deployed bytecode. It does not audit the code. > [!NOTE] > > The [Greeter reference contract](https://explorer.tavchain.safeney.com/address/0x065c1c017b8EF74f3B6001b51d188665bA9f4cd1?tab=contract) is verified on chain **771002**. Use your own deployment address when verifying your contract. ## Before you begin Complete [write and compile](/tavchain/write-contract) and [deploy and interact](/tavchain/deploy-token). Keep your contract address, original source files and compiler settings. Verification publishes your source. Review the files before submitting, including imported sources. Never include a seed phrase, private key or credential. The existing hosted Blockscout verifier processes verification requests. You do not need a wallet connection, transaction or Test TAV payment to verify source or read contract state. ## Verify through the explorer 1. Open [Tavchain's explorer](https://explorer.tavchain.safeney.com/) and search for your deployed contract address. 2. Open **Contract**, then **Verify & publish**. 3. Select a verification method. Use **Solidity (Single file)** for the tutorial's standalone Greeter source. Use **Solidity (Standard JSON input)** when you have the original compiler input, particularly for contracts with imports. 4. If you declare a license, use the one that actually applies to your source. 5. Complete the selected form with the settings used for deployment, then click **Verify & publish**. 6. Wait for the result. Open **Contract → Code** and check the verification message, contract name, source and compiler settings. For this tutorial, require **Contract source code verified (exact match)**. An indexed transaction or visible bytecode alone does not establish source verification. ### Single-file Greeter Paste the original source from [write and compile](/tavchain/write-contract) without editing it. Use these values only if you deployed with the tutorial's settings: | Setting | Tutorial value | | - | - | | Contract | Greeter | | Compiler | `v0.8.21+commit.d9974bed` | | EVM version | Shanghai | | Optimization | Enabled | | Runs | 200 | | Constructor arguments | None | | External libraries | None | A contract using other settings needs its own original values. Solidity's metadata also depends on source filenames and contents; retain both when you need an exact match. ### Standard JSON input Upload the Solidity **Standard JSON input**, including the original source filenames, source contents and compiler settings. Select the exact compiler version separately in the form. Source entries must contain literal `content`, rather than only URLs. The input is different from a compiler output file, ABI, deployed bytecode or metadata file. Do not rename source entries or change optimizer/EVM settings to match this tutorial if your deployment used different values. See [Solidity's compiler input format](https://docs.soliditylang.org/en/v0.8.21/using-the-compiler.html#input-description) and [Blockscout's verification instructions](https://docs.blockscout.com/devs/verification/blockscout-ui). ## Verify with Hardhat The [Hardhat starter](/tavchain/hardhat) provides separate configurations for deployment and source verification. From starter version 2, verify without unlocking a signing key: ```bash theme={null} npx hardhat --config hardhat.verify.config.ts verify blockscout --network tavchain CONTRACT_ADDRESS 1000000000000000000000 ``` Replace `CONTRACT_ADDRESS` with your deployment. The constructor argument above applies only to the starter's 1,000-GLD example; use your own original arguments for another contract. Verification does not require unlocking a signing key. The separate configuration preserves compiler/plugin/explorer settings while using a keyless HTTP connection. Selecting the deployment configuration can unnecessarily request `TAVCHAIN_PRIVATE_KEY`; do not provide a key just to verify source. Keep the original npm build artifacts when verifying a Hardhat deployment. Remix and npm imports can produce different metadata. ## Read the verified contract Open **Contract → Read/Write contract**. Expand **greet** to read the current greeting. The **Read** control can refresh it without a wallet signature or gas payment. The **setGreeting** method changes state. Using it requires connecting your wallet and reviewing a transaction, as explained in [deploy and interact](/tavchain/deploy-token). The demonstration contract allows anyone to change its greeting. ## Example contract Open the [verified Greeter example](https://explorer.tavchain.safeney.com/address/0x065c1c017b8EF74f3B6001b51d188665bA9f4cd1?tab=contract) at `0x065c1c017b8EF74f3B6001b51d188665bA9f4cd1` on chain **771002**. Its [deployment transaction](https://explorer.tavchain.safeney.com/tx/0x5af18cfbcaf540d8b99e800aa8cb388fb99d4dab3198ebf84e204b906d46beff) succeeded, and the explorer reports an exact source match. The source file is `Greeter.sol`, compiled with Solidity `v0.8.21+commit.d9974bed`, Shanghai, optimization enabled and 200 runs. This shared contract allows anyone to change its greeting. Its current value may differ from a tutorial's expected initial value. To verify your own instance, retain and submit its original filenames and compiler input. ## If verification fails * Confirm you selected the correct network and contract address. * Match the full compiler version, optimizer settings and EVM target used at deployment. * Check source contents, filenames, imports, library addresses and any constructor arguments. * For Standard JSON, upload the original input rather than compiler output or metadata. * If the request result is unclear, check the contract page before submitting again. You do not need to redeploy a contract to fix a verification-input mismatch. ## Related guides * [EVM contract workflow](/tavchain/contracts) * [Write and compile Greeter](/tavchain/write-contract) * [Deploy and interact](/tavchain/deploy-token) * [Transaction receipts](/tavchain/api/transaction) # Tavchain whitepaper Source: https://docs.tavchain.safeney.com/tavchain/whitepaper Read Tavchain's purpose, EVM architecture, Tavcoin economics, validator security and development direction in the versioned testnet whitepaper. Tavchain is a general-purpose EVM Layer 1 for smart contracts and applications. This whitepaper explains its purpose, architecture, Tavcoin and development direction, with current testnet capabilities distinguished from proposed features and open mainnet decisions. **Version 0.3 · Testnet edition · 4 November 2026** [Download the PDF](https://github.com/safeney/Tavchain/raw/main/docs/whitepaper/Tavchain-Whitepaper-v0.3.pdf) · [View versioned source](https://github.com/safeney/Tavchain/blob/main/docs/whitepaper/TAVCHAIN-WHITEPAPER-v0.3.md) ## Executive summary Tavchain is a general-purpose, EVM-compatible Layer 1 blockchain for smart contracts and applications. Its purpose is to provide shared infrastructure through which developers can build services that help people, businesses and institutions transact, verify information and collaborate. Its direction is shaped by Africa's needs and open to builders worldwide. \[1] The platform supports applications rather than prescribing one business model or industry. Payments, finance and DeFi are important opportunities alongside digital assets, commerce, games and verifiable records. These applications require more than a blockchain: usable interfaces, reliable data and, where relevant, asset issuers, payment providers and commercial agreements. Tavchain builds on existing open-source technology. The node derives from Cronos 1.8.1 and combines EVM execution, Cosmos SDK application modules and CometBFT-family consensus. Developers use Solidity, Ethereum-style accounts and familiar tools. Validators operate Tavchain's own consensus; the chain does not settle to Ethereum. \[1]\[2]\[3] Tavcoin, abbreviated TAV, is the native coin. In the current network, Test TAV supports transaction fees, native transfers, staking, delegation and governance participation. Test TAV has no monetary value. The testnet's allocations and economic parameters do not establish mainnet supply, distribution or redemption rights. \[4]\[5]\[6]\[7] The public testnet provides wallet access, contract deployment and interaction, source verification, a faucet, an explorer and published full-node software. Its initial four validators remain under shared administration. Broader independent operation, reliable application integrations and evidence-backed economic decisions are development priorities. \[3]\[9] Tavchain's direction is an application ecosystem with familiar EVM tools and its own network participation, native-coin economics and protocol evolution. The current foundation supports developers building and evaluating applications. Broader financial services depend on application teams, sustainable network operation and external integrations. ## 1. Purpose and intended users ### 1.1 Shared infrastructure for useful applications Tavchain's mission begins with practical application needs. People and organizations may need to coordinate payments, apply agreed rules to assets, verify that records have not changed or exchange information across organizational boundaries. A blockchain can provide a common execution and verification layer when participants need independently checkable state and cannot rely entirely on one application's database. An application can, for example, hold a token payment under an escrow rule, issue a transferable membership or anchor a document hash for later verification. Each example still needs an application team, suitable interfaces and clear responsibility for off-chain facts. An escrow contract cannot observe delivery by itself. A document hash can establish a match with submitted bytes, but cannot establish that the document's claims are true. Tavchain's Africa-informed direction concerns which problems receive attention and how applications are made usable. It does not assume that all African countries have the same infrastructure, payment systems, currencies or rules. Deployments must be designed for their actual users and providers. The same infrastructure can serve applications elsewhere. ### 1.2 A general-purpose platform Tavchain does not make one application the sole purpose of the chain. Developers can define their own contract logic and user experience within the network's capabilities. The initial developer foundation is EVM compatibility: existing Solidity knowledge, Ethereum account conventions and established development tools reduce the need for an unfamiliar application environment. Compatibility must still be checked for the particular library, compiler settings and contract behavior involved. \[1]\[9] Three audiences guide the platform: * Application developers need clear interfaces, working examples, predictable network identity and inspectable execution. * Users need understandable actions, appropriate fee information and control of their signing keys. * Node operators and contributors need public software, authenticated releases, explicit trust assumptions and maintainable upgrade procedures. No node installation is required for a user or application to use the public RPC service. Operating a node is a separate choice for verification, infrastructure or protocol participation. ## 2. Why a separate Layer 1? ### 2.1 A platform with its own evolution A separate Layer 1 allows Tavchain's protocol and participants to define its own validator participation, native-asset rules, governance and software evolution. These are the design levers that make a sovereign network different from an application deployed as contracts on another chain. That control comes with responsibility. Tavchain must sustain its own consensus security, operator participation, infrastructure and developer ecosystem. An existing EVM network may already provide stronger liquidity, wider integrations and more independent infrastructure. EVM compatibility makes many tools familiar; it does not transfer another network's validators, liquidity or economic security. Tavchain's direction is to build an EVM application ecosystem whose network participation, native-coin economics and protocol evolution can develop together. Applications can share a common execution layer while their developers retain responsibility for their products and integrations. The separate chain provides room to shape those network rules; application contracts and external providers supply the services built on top. The initial focus is a dependable developer foundation, followed by simpler payment and financial-application journeys. Fee sponsorship and connections to suitable asset and payment providers are development directions. They are not evidence of native multi-token gas, fiat liquidity or a live stablecoin service. A separate Layer 1 is justified only as these capabilities and its operator ecosystem become useful in practice. ### 2.2 Goals and how to assess them The development goals are clear application access, useful contract tooling, verifiable operation and a path toward broader participation. Progress should be assessed through reproducible user journeys, supported-platform checks, independent node and validator operation, transparent fees and useful applications. A future performance claim should state its software version, validator topology, hardware, workload, measurement interval and failure conditions. This paper makes no transactions-per-second, universal low-cost or guaranteed-availability claim. A fast isolated test cannot establish production capacity. ## 3. Architecture and technology provenance ### 3.1 Protocol layers Tavchain's node application integrates three main responsibilities. EVM execution processes supported smart-contract calls and Ethereum-style transactions. Cosmos SDK modules provide native application mechanisms including staking, distribution, slashing and governance. CometBFT-family consensus coordinates the active validators' agreement on committed blocks. \[1]\[2] A conceptual transaction path is: **Wallet or application -> JSON-RPC node -> transaction validation and propagation -> validator consensus and execution -> committed state and receipt -> application or explorer display.** The explorer is an indexing and presentation service. It is not the consensus authority. An indexing delay may affect what an explorer shows even while the chain continues producing blocks. Likewise, a reachable website is not proof that the chain is progressing. ### 3.2 Interfaces and identity Applications use Ethereum JSON-RPC for queries, gas estimation and signed EVM transaction submission. Native tooling uses separate native identifiers and interfaces. Use the correct network and address representation for each operation. \[10] The current public testnet uses EVM chain ID **771002** and native chain ID **tavchaintestnet\_771002-1**. These identify the testnet described here. A future mainnet must have its own published identity and release configuration; this paper does not assign one. A familiar account or contract address does not identify a chain. Software should check network identity before requesting a signature. Published configuration and authenticated releases provide the operational reference. ### 3.3 Validators, full nodes and services An active validator has consensus voting power and participates in committing blocks. A non-validator full node follows and verifies the chain without contributing consensus votes. Running a full node, receiving test tokens and registering a validator are distinct actions. Registration alone does not guarantee entry into the active set. \[5] RPC, explorer, faucet and status reporting have different trust and availability boundaries. Public RPC users depend on their provider; an independently operated full node provides a separate verification route. ### 3.4 Inherited technology and Tavchain changes Tavchain does not claim to have invented the EVM, Cosmos SDK or CometBFT consensus. Its published source includes upstream attribution and a record of changes to eight paths covering application configuration, command identity, address prefixes, build and network metadata. These modifications must not be presented as a new consensus design. \[11] The node source is distributed under Apache 2.0, with upstream notices and dependency terms retained. Released packaging and dependencies have their own included notices. Public code supports inspection and contributions; it does not expose or grant control of validator keys, wallets or infrastructure administration. ## 4. Consensus, security and participation ### 4.1 Finality and availability A block is committed after valid precommits representing more than two-thirds of the current validator voting power. Under the protocol's consensus assumptions, including less than one-third faulty voting power, committed blocks have deterministic finality. The threshold concerns voting power, not a simple count of machines. Quorum loss can stop new blocks. \[3] Tavchain is a Layer 1 with its own validator security model. Its EVM interface does not mean that Ethereum secures or settles its blocks. Additional confirmations do not remove the risks associated with shared validator administration. ### 4.2 Current control model The initial public-testnet set consists of four validators under shared administration. Several share a hosting failure domain. They must not be represented as four independent organizations or four independent security domains. A shared outage can affect consensus availability; compromise of sufficient voting power can compromise network security. \[3] Broader participation requires separately controlled operators with their own key custody and operational responsibility. More processes on the same controlled hosts do not establish decentralization. The current public release documentation identifies independent operator acceptance as pending. \[9] ### 4.3 Staking and delegation The testnet uses the native staking module with atav as its bond denomination. Validators register consensus public keys and self-delegation using native tools. Delegators bond Test TAV to validators. Active membership is selected by bonded stake within the configured set limit, currently up to ten validators. \[5] The documented testnet unbonding period is 21 days. Downtime and double-signing penalties can affect staked funds. Commission rates are declared by validators within their configured constraints. Users must inspect the current parameters and validator information before acting; these figures are testnet settings rather than immutable mainnet commitments. ### 4.4 Layered security responsibility Consensus security, contract correctness, wallet safety and service reliability are separate concerns. A successful receipt establishes an execution result recorded in a block; it does not establish the safety or value of an application. Verified source links published code to deployed bytecode under the verifier's matching rules; it is not a security certification. The current testnet is unaudited. Security work includes implementation review, automated checks, scoped runtime acceptance, public source inspection and private vulnerability reporting. This paper does not assert that these activities eliminate defects or constitute an independent audit. Wallet recovery phrases and private keys remain with their owners. Public services and support do not need them. Security reports should be sent privately to **[support@safeney.com](mailto:support@safeney.com)** with enough information for safe investigation and without credentials or personal data. ## 5. Tavcoin and network economics ### 5.1 Native asset roles Tavcoin, or TAV, is the network's native coin. It has 18 decimal places; one TAV equals 10^18 atav. Native transfers move TAV between accounts. Network fees are paid in TAV. Native staking, delegation and governance use the chain's native modules and voting-power rules. \[4]\[5]\[7] Application tokens such as ERC-20s are separate assets defined by contracts. Their names and symbols do not establish issuer identity, backing or value. Their balances do not automatically replace the TAV required for network fees. An application's token policy must be evaluated independently of native network economics. ### 5.2 Current testnet allocation The testnet genesis allocates **1,000,000 Test TAV**. Four operator accounts receive 2,000 each; the faucet receives 50,000; a validator-grant reserve receives 50,000; and the test reserve receives 892,000. Each initial validator self-bonds 1,000 Test TAV from its operator allocation. The reserve does not automatically refill the faucet. \[4] These allocations support network development. Test TAV has no monetary value, and test balances have no announced redemption, airdrop or mainnet conversion entitlement. This allocation is not a mainnet distribution schedule. ### 5.3 Current fee distribution The testnet distributes transaction fees through the native distribution module. Its configured inflation rate is zero. The community pool receives 2% of distributed fees; validator commission and delegator shares are accounted for by the module. Empty blocks do not create an inflation subsidy. Accrued accounting, withdrawable rewards and withdrawn wallet balances are distinct. \[6] No fixed return is promised. Activity, stake, commission and applicable rules affect distribution. On a future valuable-asset network, security sustainability would require a deliberate assessment of operator costs, fee demand and any approved issuance or funding policy. Testnet configuration alone does not establish an economically sustainable mainnet. ### 5.4 Mainnet economic decisions This edition does not set mainnet total supply, issuance, allocations, vesting, treasury controls, validator subsidies, grant policy or sale terms. Those decisions require a separate economic design and explicit approval. The eventual published design should explain who can change parameters, how changes take effect and how participants can evaluate supply and distribution. The role of TAV is protocol utility. This paper provides no price forecast, exchange-listing commitment or assurance of financial return. ## 6. Application and payment experience ### 6.1 Developer access Developers can build and interact with Solidity contracts using the documented Remix and Hardhat workflows. The published tutorials include simple contract and ERC-20 examples with deployment and verification guidance. The reference compiler settings use Solidity 0.8.21 with a Shanghai EVM target; other combinations require their own compatibility checks. \[9] Wallet users connect a supported custom EVM network, obtain Test TAV and submit reviewed actions. Node operators can use published native bundles or the separately documented Docker route. Supported full-node downloads include Linux x86-64, Linux ARM64 and Windows x86-64. These non-validator acceptance results do not establish validator-signing support for every platform. \[9] The detailed setup, API limits and release commands belong in living documentation. Keeping those instructions separate allows the whitepaper to explain the design without becoming an installation manual. ### 6.2 Payments and financial applications Contracts can express token transfers, escrow conditions, asset issuance and financial application rules. The network provides shared execution; applications provide their products, risk controls and users' interfaces. Neither EVM compatibility nor a token contract creates fiat convertibility, issuer-backed stablecoins or reliable price feeds. On-ramps and off-ramps connect blockchain assets to external payment systems. Their availability depends on providers, supported networks and assets, liquidity and the arrangements required for each market. They cannot be created merely by declaring support in a whitepaper. Tavchain's current public release does not provide an official bridge or IBC asset-transfer route. \[8]\[9] Stablecoin and payment-provider connectivity are development opportunities. No confirmed partner, supported fiat corridor or available real-money product. ### 6.3 Fee sponsorship direction A user experience can hide the need to hold native gas without changing the underlying fee asset. A sponsor-funded smart-account flow pays network fees in TAV on the user's behalf. A token-reimbursement flow can charge a supported application token while the sponsor or bundler still pays TAV underneath. Fee sponsorship and supported-token reimbursement are development directions. A user-facing service would need to demonstrate bounded permission, transfer, charge/refund accounting and allowance removal on its actual deployment. This paper does not claim public availability, real-token pricing, rebalancing liquidity, all-wallet compatibility or unrestricted sponsorship. A public service would need funded fee capacity, supported-action rules, authenticated ownership, durable request accounting and a clear recovery path. It should show the action, fee limit and spending permission before signing. Future token reimbursement must explain who bears exchange-rate and liquidity risk. No such service is announced as publicly available by this paper. ## 7. Governance and software evolution The current testnet uses native governance based on bonded voting power. It is not one-wallet-one-vote. Ordinary proposals currently require a minimum deposit of 100 Test TAV and have a 24-hour voting period. Documented quorum is 0.334, approval threshold 0.5 and veto threshold 0.334 under the native tally rules. Expedited proposals require 500 Test TAV and have a six-hour voting period. \[7] These parameters do not fully describe every proposal outcome. Native rules distinguish voting options and deposit outcomes. Passing a vote does not guarantee that a requested action executes successfully. Software upgrades also require compatible releases and coordinated operator procedures. Source maintenance and protocol governance are distinct. A repository contribution or merge does not itself change the running network. Conversely, an onchain decision does not make operators independently controlled or automatically perform every required infrastructure action. A mainnet governance design must clearly describe authority, supported changes, operational adoption and the limits of emergency intervention. This paper does not create new governance powers or promise a particular mainnet constitution. ## 8. Evidence and current boundaries ### 8.1 Public capabilities As documented on 4 November 2026, Tavchain Testnet provides native transfers, Solidity deployment and interaction, example-token development, contract-source verification, HTTP JSON-RPC, an explorer, a faucet and public full-node software. Native staking, delegation, fee distribution and governance are enabled. \[1]\[5]\[6]\[7]\[9] Published node checks cover scoped synchronization, state comparison and graceful restart on documented environments. These are evidence of the tested behaviors, not an unlimited-capacity or fault-tolerance guarantee. The descriptions here follow the published release documentation; they are not a new code or onchain audit. ### 8.2 Limits that matter to users The initial validators are centrally administered. Independent operator acceptance remains pending in the current release documentation. No official bridge, IBC asset-transfer route or mainnet balance conversion is available. Public WebSocket RPC and debug tracing are not offered. Hosted services are best effort and have no uptime SLA. \[9] These boundaries should be updated when accepted evidence and the public deployment change. Private development results must not silently become claims about the live network. The paper's version and references identify its scope; live service status belongs on the status page. ## 9. Development direction and milestones Tavchain's direction is to improve a reusable platform for useful applications, rather than claim that the blockchain itself supplies every financial or institutional service. The following milestones organize that direction without assigning unapproved launch dates. **Builder access:** maintain working wallet, contract, verification and node journeys; simplify entry points and publish compatible releases with clear support boundaries. **Broader participation:** complete acceptance with separately controlled operators and demonstrate that registration, active voting power, key custody and ongoing operation are understood and verifiable. **Application usability:** develop a public-testnet sponsorship integration with clear permission and fee review. Verify accounting, interrupted requests and allowance cleanup before expanding access. **Useful integrations:** evaluate provider and application needs with evidence from actual users. Announce corridors, supported assets or partnerships only after concrete arrangements and acceptance exist. **Mainnet design:** resolve supply and incentives, validator distribution, governance authority, security readiness, operational recovery and asset/provider dependencies before announcing a launch configuration. Mainnet readiness is a combined technical, operational and economic decision. A whitepaper, repository publication or successful testnet transaction does not by itself settle that decision. ## 10. Open development and review Tavchain publishes node source and network configuration through **github.com/safeney/Tavchain**. Developers can inspect the implementation and submit contributions under the repository's contribution process. Public software licensing allows reuse under its terms; it does not transfer control of the Tavchain network or ownership of project accounts. \[11]\[12] The whitepaper should remain versioned alongside its supporting documentation. Significant revisions should identify which protocol release, network state or policy decision changed. Public feedback can improve the paper; sensitive vulnerability reports belong in the private reporting channel. This edition describes the public testnet and the platform's development direction. Subsequent editions should identify changes to implemented behavior, evidence and approved policy. Mainnet economic decisions remain open. ## References Current Tavchain sources were retrieved on 4 November 2026. All numbered references are public. Network parameters describe the documented testnet at that date and should be checked against the current release before operational use. \[1] About Tavchain. [Read source](/tavchain/about) \[2] Network architecture. [Read source](/tavchain/learn/architecture) \[3] Consensus, finality and security. [Read source](/tavchain/learn/security) \[4] Tavcoin. [Read source](/tavchain/learn/tavcoin) \[5] Staking and delegation. [Read source](/tavchain/learn/staking) \[6] Network rewards. [Read source](/tavchain/learn/rewards) \[7] Governance and upgrades. [Read source](/tavchain/learn/governance) \[8] Development and roadmap. [Read source](/tavchain/learn/history) \[9] Release status. [Read source](/tavchain/status) \[10] Network information. [Read source](/tavchain/network) \[11] Tavchain modifications and source permissions. [Read source](https://github.com/safeney/Tavchain/blob/main/node/TAVCHAIN-MODIFICATIONS.md) \[12] Tavchain public source repository. [Read source](https://github.com/safeney/Tavchain) Foundational and comparative reading: Bitcoin's original paper, [Read source](https://bitcoin.org/bitcoin.pdf) ; Ethereum's original whitepaper, [Read source](https://ethereum.org/whitepaper/) ; the Cosmos original paper, [Read source](https://github.com/cosmos/cosmos/blob/master/WHITEPAPER.md) ; Celo research catalogue, [Read source](https://celo.org/whitepapers) ; Base protocol overview, [Read source](https://docs.base.org/specifications/base-protocol/overview) . These explain related designs and publication approaches, not proof of Tavchain-specific behavior. ## Version history v0.3 - 4 November 2026. Testnet edition covering purpose, architecture, participation, native-coin economics and development direction. Mainnet economic policy and launch arrangements remain open. # Write and test a contract Source: https://docs.tavchain.safeney.com/tavchain/write-contract Create and compile a Solidity Greeter in Remix with the Tavchain tutorial settings, ready for deployment through an EVM wallet. Build a small Solidity contract in [Remix](https://app.remix.live/), then deploy it with MetaMask on Tavchain Testnet. You do not need a node, terminal or private-key export for this browser workflow. ## Before you begin Use a desktop browser with MetaMask installed. [Add Tavchain Testnet](/tavchain/connect) and obtain [Test TAV](/tavchain/faucet). Keep your seed phrase and private key inside your wallet. ## Create Greeter Open Remix's file explorer, create `Greeter.sol` at the root of your workspace and paste the example below. It starts with `Hello`, lets anyone change the greeting and emits an event for each change. It is a demonstration contract with no ownership restriction. ```solidity Greeter.sol theme={null} pragma solidity 0.8.21; contract Greeter { string public greeting; event ChangeGreeting(address from, string value); constructor() public { greeting = "Hello"; } function setGreeting(string memory _greeting) public { greeting = _greeting; emit ChangeGreeting(msg.sender, _greeting); } function greet() public view returns (string memory) { return greeting; } } ``` Solidity reports warnings for this example's missing SPDX identifier and ignored constructor visibility; neither is a compilation error. This simple demonstration is not an audited application or a contract for holding funds. ## Compile Greeter In **Solidity Compiler**, select: | Setting | Value | | - | - | | Compiler | `0.8.21+commit.d9974bed` | | Language | Solidity | | EVM version | Shanghai | | Optimization | Enabled | | Runs | 200 | Open **Advanced Configurations** to find the EVM target and optimizer. Click **Compile Greeter.sol**, then select **Greeter** in the contract selector. Resolve any compilation errors before continuing. Retain the source, compiler settings, ABI and bytecode. Keep the original Standard JSON compiler input when your build produces it; it can be used for [source verification](/tavchain/verify-contract). Changing the source filename can change Solidity's metadata and full bytecode even when the executable logic is unchanged. ## Continue to deployment Follow [deploy and interact](/tavchain/deploy-token) to connect MetaMask, deploy once and read `Hello`. You can then make the optional `Hello Tavchain` update and [verify the source](/tavchain/verify-contract). The [verified Greeter example](https://explorer.tavchain.safeney.com/address/0x065c1c017b8EF74f3B6001b51d188665bA9f4cd1?tab=contract) uses this source as `Greeter.sol` with the settings above. Use your own deployment for a predictable initial greeting. Use the compiler and EVM settings above for this example. Check compatibility before changing compiler versions or targeting a different EVM revision. ## Related guides * [EVM contract workflow](/tavchain/contracts) * [Network settings](/tavchain/network) * [Transaction receipts](/tavchain/api/transaction)