Chain Reference

This page covers what you can call and what you can read on an AETRON chain that includes the AetronPoI pallet. It is a working reference for the calls a participant needs, not a full listing: the pallet exposes over a hundred extrinsics, and most of them are governance switches or internal finalization steps that ordinary participants never touch.

Reading This Reference

Call indices are stable identifiers inside the AetronPoI pallet. They apply only to a runtime that has the pallet installed, and the values here were read from the live mainnet metadata, where the pallet sits at index 29. A runtime without AetronPoI has none of these calls at all, and a pallet index can move between runtime versions, so always resolve the pallet and call by name against the chain metadata rather than hardcoding numbers. Both public networks and their RPC endpoints are listed in Networks and Endpoints.

Two key types appear throughout. A coldkey is the account that owns funds and signs registration, staking, and lifecycle calls. A hotkey is the operational key a Miner runs with, and it signs work submissions. One hotkey serves exactly one task.

Registration and task fees are split 90/5/5 between the recirculation pool, the treasury, and the validator pool. Fees are charged, not locked, so they do not come back when you dissolve a Neuronet.

Neuronets and Tasks

create_neuronet (0)

Creates a Neuronet with its first task. Signed by the future owner. The call validates the task config, charges the current registration cost, writes the Neuronet record, and initializes its emission settle state with a snapshot of the current accumulator so that a new Neuronet cannot claim historical emission.

The cost follows an EMA curve rather than a fixed price: the runtime base is 1000 AET for a public Neuronet and 5000 AET for a Confidential one, and each successful registration bumps the current cost, which then decays back toward the base over time. The caller must hold the cost plus the existential deposit, since the withdrawal keeps the account alive.

An optional initial_stake argument delegates stake to the new Neuronet in the same transaction. Without it the Neuronet starts at zero total stake and needs delegate_stake before it becomes eligible.

While the chain is in its launch phase, this call also checks the signing coldkey against the on-chain allowlist and fails with NotInLaunchAllowlist otherwise. The same gate applies to transfer_neuronet_ownership and burned_register. Mainnet has the phase on today, testnet has it off.

add_task (3)

Adds a further task to an existing Neuronet. Owner only. Requires that the task id is not already taken and that the Neuronet is below MaxTasksPerNeuronet, which the runtime sets to 64. Charges TaskCreationCost, a flat 10 AET in the runtime, with the same 90/5/5 split. The task config is validated by the same rules as at creation, so model identity, verification tier, and execution parameters must be internally consistent. See Task Configuration for what those fields mean.

Related owner calls: dissolve_neuronet (1), remove_task (4), update_task_weight (5), decrease_owner_fee (6, the fee can only be lowered), set_bootstrap_peers (7), set_gateway_url_hint (8), and transfer_neuronet_ownership (134).

Miners

burned_register (10)

Registers a Miner into a specific task by burning AET. Signed by the coldkey, which pays and takes custody, while the hotkey passed as an argument becomes the working identity. The call checks that the Neuronet and task exist, that the hotkey is not already registered anywhere, that the active Miner count is below MaxActiveMiners (100000 in the runtime), and that the declared Pulse attestation clears both the task minimum and the ceiling of the hardware tier it claims. The declared endpoint is a bounded value of at most 128 bytes.

If the task uses Manual approval, the hotkey must already appear in the owner's invitation list and the invitation must not have expired. Under Auto or Open approval the registration proceeds directly, and under Open the owner can eject the Miner afterwards without a refund.

The burn cost also follows an EMA, with a runtime base of 0.1 AET. When bond enforcement is switched on, the coldkey additionally reserves RequiredMinerBond, set to 1 AET in the runtime, before the burn is charged.

The last argument is hotkey_proof: Option<[u8; 64]>, an sr25519 signature made by the hotkey itself over blake2_256("AETRON-PoI:hotkey-registration:v1" || coldkey || hotkey || neuronet_id || task_id). It proves the caller actually controls the hotkey it is registering, which stops anyone from squatting somebody else's key. Whether it is required is governed by the RequireHotkeyProof storage flag, and the two networks currently differ: testnet has it on, mainnet has it off. Sending None against testnet fails with HotkeyProofRequired, so treat the proof as mandatory when you write a client.

deregister_miner (12)

Removes a Miner from a task. Signed by the coldkey. The call clears the Miner entry, the active registry, the task membership, the declared VRAM, and the identity deposit, and it decrements the active Miner count. The registration burn is not returned.

The hotkey argument is optional. One coldkey may legitimately hold several hotkeys in the same task, for example an operator running several cards, and without an explicit key the runtime removes the first match it finds while scanning storage, which is an arbitrary choice. Name the hotkey unless the task holds exactly one.

Related Miner calls: swap_hotkey (14) to rotate the working key while keeping membership and reputation, set_miner_encryption_key (15) to publish the X25519 key used for sealed prompts, and deposit_bond (117) with withdraw_bond (118) for the stake-at-risk bond.

Work and Verification

submit_artifact (40)

The executing Miner commits the proof of one job. Signed by the hotkey, which must be a registered Miner bound to a Neuronet and task. The call enforces several things at once: the artifact signature must be valid over the canonical payload when signatures are required, the output hash must not have been claimed for this job before, and the nonce must be unused for this Miner. Both rules exist to stop a Miner from replaying an earlier answer.

When job assignment commitment is enabled, the artifact is only accepted against an assignment the owner posted in advance, matching both the assigned hotkey and the canonical input hash. On first submission for a job the runtime freezes the verifier selection seed, the VRAM requirement, and a digest of the candidate pool, so the quorum cannot be reshaped once replay begins.

submit_aggregated_batch (41)

The Neuronet owner submits one aggregated Merkle root for an epoch, along with the total request count and per Miner entries. This is the call that consumes Neuronet capacity and credits useful work, which is what emission is computed from. It is idempotent per Neuronet and epoch, so a second submission for the same epoch is rejected.

submit_validation (44)

An assigned verifier reports the signals it measured while replaying a job. Signed by the verifier's hotkey. The verifier does not submit a verdict: it submits the measured signals, and the runtime derives the verdict from them through a deterministic integer gate. That removes the option of a lazy or colluding verifier simply asserting an outcome.

Verdicts accumulate into a quorum of KQuorumK verifiers, which the runtime sets to 20, with a threshold KQuorumT of 10 needed for a fraud outcome. Use submit_validation_revealed (90) when the verifier posted a blind commit first through submit_verdict_commit (80), since that variant binds the reveal to the commit and blocks copying somebody else's result. finalize_job_quorum (52) closes a job once the votes are in.

Staking

delegate_stake (60)

Reserves AET on the staker's account and credits it to a Neuronet. The Neuronet must exist, and the amount must meet MinStakerDelegation, which the runtime sets to 1 AET. Stake becomes eligible for rewards only from the next full epoch, which removes the option of staking just before a payout.

request_unstake (61)

Queues a withdrawal. The stake leaves the Neuronet's total immediately and returns to free balance after UnstakeCooldown, 50400 blocks or roughly 7 days. When unstake friction is enabled, larger or repeated exits fall under ExtendedUnstakeCooldown of 216000 blocks, roughly 30 days. Partial amounts are allowed.

move_stake (62)

Redelegates from one Neuronet to another through the same cooldown pipeline, so the stake is not usable in the destination until the cooldown has passed. The destination Neuronet must exist.

Storage Worth Reading

All of these live under the AetronPoI pallet.

Item	Key	What it holds
Neuronets	NeuronetId	Owner, first task config, status, lock amount, activity block
Tasks	NeuronetId, TaskId	Full task config for each task
NeuronetOwner	NeuronetId	Current owner account
Miners	hotkey	Miner entry: coldkey, endpoint, GPU class, Pulse score, reputation
MinerHotkeyToNeuronet	hotkey	The single (NeuronetId, TaskId) the hotkey serves
ActiveMinerRegistry	NeuronetId, hotkey	Live registry used to draw verifier candidates
Stake	staker, NeuronetId	Delegated amount
TotalNeuronetStake	NeuronetId	Sum of stake, used for activation and capacity
StakeActivation	staker, NeuronetId	When the stake becomes reward eligible
PendingUnstake	staker, NeuronetId	Queued withdrawal and its unlock block
ArtifactRegistry	JobId	Committed artifact record for a job
JobExecutor	JobId	Which hotkey executed the job
JobVerdictQuorum	JobId	Accumulated verifier votes
JobFinalized	JobId	Settled verdict once the quorum closes
AggregatedBatches	NeuronetId, epoch	Owner batch root and request counts per epoch
CurrentEpoch	value	Current epoch counter
TotalPoiIssuance	value	AET issued through Proof of Intelligence, the basis for halving
EmissionPaused	value	Whether emission is running

Neuronet epochs advance on a tempo, which defaults to 7200 blocks and can be changed per Neuronet through set_neuronet_tempo (132).

Governance Calls

A large share of the pallet consists of sudo calls that switch enforcement on or off: verifier selection, bond enforcement, tolerance verdicts, withholding penalties, witness challenges, Pulse challenge enforcement, and the registration cost parameters. They exist so that verification layers can be calibrated and activated one at a time rather than all at once. They are listed here for completeness because they explain why a call can succeed on one chain and behave differently on another, and they are not callable by ordinary accounts.

Where to Go Next

• Gateway API: the HTTP surface, for when you do not want to sign chain calls directly.
• Task Configuration: what goes into the task config passed to create_neuronet and add_task.
• Neuronet State: how to read a Neuronet's on-chain state.
• Proof of Intelligence: why artifacts, quorums, and verdicts work the way they do.
• How to Stake: the staking flow from a participant's point of view.