Networks and Endpoints

AETRON runs two public networks. Mainnet carries real AET, testnet carries worthless AET and exists so that new runtime versions and new Neuronets can be tried out before they touch the main chain. Both run the same runtime, so anything you build against one works against the other.

At a Glance

	Mainnet	Testnet
Chain name	AETRON	AETRON Testnet
RPC over WebSocket	wss://entrypoint-mainnet.aetron.ai	wss://entrypoint-test.aetron.ai
RPC over HTTPS	https://entrypoint-mainnet.aetron.ai	https://entrypoint-test.aetron.ai
EVM chain id	3355 (0xd1b)	3356 (0xd1c)
Explorer	explorer.aetron.io	explorer.aetron.io, network switch in the header
Explorer REST API	https://api-explorer.aetron.io/mainnet/api	https://api-explorer.aetron.io/testnet/api
Managed gateway	not published yet	https://gateway-testnet.aetron.ai
Console	app.aetron.io	app.aetron.io

The same host serves both the Substrate JSON-RPC and the Ethereum JSON-RPC. Which one you get depends on the method you call, not on the URL.

Chain Parameters

These hold on both networks:

• Token: AET, 9 decimals. The chain counts in planck, its smallest indivisible unit, the way Ethereum counts in wei: one AET is 1,000,000,000 planck. Every amount in an extrinsic or a storage item is in planck, never in whole AET.
• Address format: SS58 prefix 42, the generic Substrate format. The same address works in Polkadot.js, Talisman, SubWallet and the AETRON extension.
• Block time: 12 seconds, Aura for authoring and GRANDPA for finality.
• Existential deposit: 500 planck.
• Epoch: 7200 blocks, roughly 24 hours.
• The AetronPoI pallet sits at index 29 in the runtime.

Read the runtime version from the chain rather than trusting a number written down anywhere, including here:

curl -s https://entrypoint-mainnet.aetron.ai \
  -H 'Content-Type: application/json' \
  -d '{"id":1,"jsonrpc":"2.0","method":"state_getRuntimeVersion","params":[]}'

Connecting to the Substrate RPC

Any Substrate tool works. Polkadot.js Apps opens the chain with the endpoint in the URL:

https://polkadot.js.org/apps/?rpc=wss%3A%2F%2Fentrypoint-mainnet.aetron.ai

From code, with @polkadot/api:

import { ApiPromise, WsProvider } from '@polkadot/api';

const api = await ApiPromise.create({
  provider: new WsProvider('wss://entrypoint-mainnet.aetron.ai'),
});

const { specVersion } = api.runtimeVersion;
const epoch = await api.query.aetronPoI.currentEpoch();
console.log(specVersion.toString(), epoch.toString());

Note the capitalisation: the pallet is AetronPoI in metadata, which the JS API exposes as api.query.aetronPoI.

Plain HTTP works too, which is handy for scripts and health checks:

curl -s https://entrypoint-test.aetron.ai \
  -H 'Content-Type: application/json' \
  -d '{"id":1,"jsonrpc":"2.0","method":"system_health","params":[]}'

The public entrypoints expose the safe RPC set. Node-operator methods such as key insertion or peer management are rejected. If you need those, or archive state, or no rate limit at all, see Running a Node.

Connecting to the EVM RPC

The same host answers Ethereum JSON-RPC, so MetaMask, ethers, viem, Hardhat and Foundry all work without a proxy.

Field	Mainnet	Testnet
Network name	AETRON	AETRON Testnet
RPC URL	https://entrypoint-mainnet.aetron.ai	https://entrypoint-test.aetron.ai
Chain ID	3355	3356
Currency symbol	AET	AET
Decimals in the EVM	18	18

curl -s https://entrypoint-mainnet.aetron.ai \
  -H 'Content-Type: application/json' \
  -d '{"id":1,"jsonrpc":"2.0","method":"eth_chainId","params":[]}'
# {"jsonrpc":"2.0","id":1,"result":"0xd1b"}

One thing to keep in mind: the native chain counts AET in 9 decimals, the EVM layer in 18. Frontier scales between them, so the same balance looks different depending on which side you query. See EVM Compatibility.

Explorer and Its API

explorer.aetron.io shows blocks, extrinsics, events, accounts, transfers and the PoI state: Neuronets, miners, stake and emission. The network switch in the header moves between mainnet and testnet.

The explorer's backend is open for reading and needs no key. Every route is prefixed with the network:

https://api-explorer.aetron.io/{mainnet|testnet}/api/...

Routes worth knowing:

Route	Returns
/blocks, /blocks/{id}	Block list and one block by height or hash
/extrinsics, /extrinsics/{id}	Extrinsics with their call, signer and result
/events, /events/{eventId}	Decoded runtime events
/accounts, /accounts/{address}	Account balances, plus /balance-history and /stake-history
/transfers	AET transfers
/validators	Block validator set
/network-stats	Head block, total issuance, total stake, counters
/runtime/spec-versions/latest	The runtime version currently indexed
/poi/chain	PoI state: epoch, emission flag, Neuronet and miner counts, registration cost
/poi/neuronets, /poi/neuronets/{id}	Neuronet registry and one Neuronet in detail
/poi/neuronets/{id}/miners, /staking, /emissions	Miners, stakers and emission history of one Neuronet

List routes take limit and offset:

curl -s "https://api-explorer.aetron.io/mainnet/api/blocks?limit=5"
curl -s "https://api-explorer.aetron.io/testnet/api/poi/neuronets"

The data comes from an indexer, not from the node directly, so it trails the head by a few blocks. When a value has to be exact, for example a balance before a transfer, read it from the RPC.

Two practical notes. The API is rate limited to 600 requests per minute and answers 429 past that. And it sits behind Cloudflare, where a connection held open for a long run of requests can stall for tens of seconds; a client that reuses one keep-alive socket for a tight polling loop will see that as the API hanging. Pace the polling, or open a fresh connection.

Gateways

A gateway is the HTTP entry point into a Neuronet: it authenticates the caller, picks a miner, runs the job and returns the answer. It is off-chain infrastructure, and there can be many of them. Anyone can run one.

The managed testnet gateway is public:

curl https://gateway-testnet.aetron.ai/healthz
# ok

A managed mainnet gateway is not published yet. Until it is, a mainnet Neuronet is served either by a gateway its owner runs or by an operator the owner has an agreement with, and the address of that gateway comes from them. The API Quickstart and the Gateway API Reference cover the request surface itself, which is the same wherever the gateway runs.

Console

app.aetron.io is the web console: create a Neuronet, configure its tasks, issue API keys, watch usage and spend. It talks to the same networks listed above and lets you switch between them.

Which Network to Use

Use testnet while you are building. Registration there is open to anyone, it costs testnet AET, and a broken task config can be thrown away rather than dissolved.

Three differences matter in practice. Mainnet is still in its launch phase, so creating a Neuronet or registering a miner there requires an allowlisted coldkey. Emission is paused on mainnet and running on testnet, so work on the main chain earns nothing yet. And the managed gateway exists only on testnet. See Project Status for the current state of both.