Aether is a collection of 1,000 NFTs on Ethereum, paired with a token called $AETH. They are not two separate things — they are one contract. Aether is built on the DN404 standard, where an ERC-20 token and an ERC-721 NFT collection are co-joined into a single contract.
The link is a fixed ratio: 1,000 $AETH equals one Aether NFT. When an address's token balance crosses a multiple of 1,000, an NFT is created for it; when the balance falls below that multiple, an NFT returns to the pool. The collection is permanently capped at 1,000 NFTs.
Holding an Aether NFT is not passive in effect — each NFT earns $AETH every block, and a share of trading fees flows back to holders. The sections below describe each mechanic precisely.
Aether uses DN404. The ERC-20 side ($AETH) and the ERC-721 side (the NFTs) mirror each other. You do not "convert" tokens into an NFT — crossing the 1,000-token threshold materializes one automatically, and the contract keeps the two sides in sync on every transfer.
Total supply at launch is 1,000,000 $AETH: 1,000 NFTs times 1,000 tokens each. The emission system (Section 4) mints additional $AETH over time, but the NFT count never exceeds 1,000 — a hard cap is enforced in the contract.
An NFT that is not currently held by anyone is "unminted" — its backing tokens sit in the liquidity pool or with an address that has the DN404 "skip NFT" flag set. NFTs cycle in and out of existence as balances move; this is normal DN404 behaviour, not an error.
The 1,000:1 coupling
A fee of 0.5% is taken on buys and 0.5% on sells. A buy is any transfer from the Uniswap V2 pair; a sell is any transfer to it. Wallet-to-wallet transfers are never taxed.
The fee is hard-capped in the contract at 1% — there is no function, governance or otherwise, that can raise it beyond that ceiling.
Each collected fee is split between two destinations: a reward pool for NFT holders, and a burn address. The split is adjustable by the project (within the cap) and starts at 100% to the reward pool. The reward-pool portion is sent to a separate RewardDistributor contract and booked for holders to claim.
Fee flow
Every Aether NFT emits $AETH every block it is held. No staking, no locking, no deposit — the NFT earns simply by sitting in a wallet.
The emission rate is not fixed. Each NFT emits at a rate that decays as $AETH moves out of the liquidity pool and into holders' hands. The rate is the maximum rate multiplied by the pool's share of total supply (a linear decay). Early on, when most supply is in the pool, emissions run near maximum; as the project grows and tokens distribute, the rate falls automatically toward zero. This makes emissions self-regulating — there is no endless inflation.
Rewards accrue per NFT. When an NFT changes hands, any unclaimed rewards are automatically settled to the outgoing holder before the transfer completes, and the new holder starts earning fresh from that block. Nothing is lost on transfer, and nothing is double-counted.
Claiming is done per wallet through the dashboard — one claim settles every NFT you currently hold and mints the total as $AETH.
Emission accrual and claim lifecycle
Why the rate decays
Separately from emissions, the reward-pool portion of every trading fee is distributed across all 1,000 Aether NFTs. Each NFT has an equal, claimable share. Holders claim per NFT through the dashboard.
Fee-pool rewards left unclaimed for roughly 30 days expire: the expired portion is burned rather than paid. This rewards holders who claim, and keeps stale unclaimed value from accumulating indefinitely. Claim regularly so nothing is lost.
The distribution uses an accumulator: when fees arrive, the per-NFT entitlement increases; each NFT's claim pays out what has accumulated since its last claim. This is efficient regardless of how many holders there are — there is no loop over holders.
Fee-pool distribution
Aether launched by adding liquidity to a Uniswap V2 pool. There is no separate "enable trading" toggle — trading is live once liquidity exists.
At launch, a temporary max-wallet limit applies: a single wallet may hold at most 2% of supply (20,000 $AETH). This limit increases every block and lifts completely after roughly 20 minutes, after which there is no wallet cap.
Its purpose is narrow: to blunt a single large snipe in the first blocks of trading. It is friction, not a guarantee — it does not prevent someone splitting holdings across multiple wallets. After launch, the limit is a pure function of block number; no one can pause, extend, or re-tighten it.
Max-wallet ramp
The only function that mints new $AETH is the emission claim. There is no admin or owner mint function — it does not exist in the contract. The project owner cannot create tokens, cannot mint to themselves, and cannot inflate supply.
When you claim, the amount is determined entirely by a formula — blocks elapsed multiplied by the current emission rate. The caller supplies no number and cannot influence the amount. You can only ever claim for NFTs you currently hold. A hard ceiling on total emitted supply is enforced as a backstop, so even a logic error cannot mint without limit.
Administrative functions are held by a timelock, meaning any change is visible on-chain before it can take effect. The contracts are open-source and verified on-chain — anyone can read the mint logic directly.
Below are the key functions that implement the mechanics above, with notes on what each does. These are excerpts — the complete verified source is on the Mint & Contracts page with Etherscan links.
_transfer)function _transfer(address from, address to, uint256 amount)
internal virtual override
{
bool isBuy = (from == uniswapV2Pair);
bool isSell = (to == uniswapV2Pair);
uint256 fee = (amount * feeBps) / BPS_DENOMINATOR;
uint256 toBurn = (fee * burnShareBps) / BPS_DENOMINATOR;
uint256 toRewards = fee - toBurn;
super._transfer(from, to, amount - fee); // net amount to recipient
// burn leg and reward leg follow...
}effectiveRate)function effectiveRate() public view returns (uint256) {
if (uniswapV2Pair == address(0)) return 0;
uint256 ts = totalSupply();
if (ts == 0) return 0;
uint256 poolBalance = balanceOf(uniswapV2Pair);
return (MAX_RATE * poolBalance) / ts;
}claim)function claim() external returns (uint256 claimed) {
// settle every NFT the caller holds, crediting accruedRewards
claimed = accruedRewards[msg.sender];
require(claimed != 0, "nothing to claim");
require(totalEmitted + claimed <= MAX_EMISSION_SUPPLY, "emission cap reached");
accruedRewards[msg.sender] = 0;
totalEmitted += claimed;
_mint(msg.sender, claimed);
}_afterNFTTransfers)function _afterNFTTransfers(
address[] memory from, address[] memory to, uint256[] memory ids
) internal override {
require(_totalNFTSupply() <= MAX_NFT_SUPPLY, "NFT cap exceeded");
// ...emission settle logic follows
}Live on Ethereum mainnet. Full list and Etherscan links: Mint & Contracts.