How CORE works: stake WATT, hold an AMP stake, earn the fees

You hold WATT, or the WATT/PLS pool token from PulseX. You approve the Staker for exactly the amount you are about to stake and send one transaction. The Staker takes the tokens, mints AMP for them on the curve described below, and mints you an NFT that records all three: the WATT, the LP and the AMP. The console calls that NFT an AMP stake.

From then on the stake earns. Every time someone sweeps the fee collectors into the pool, each reward token is split among all stakes in proportion to their AMP, and your share waits inside the contract until you claim it. You can claim one token at a time or all of them, add more WATT or LP to the same stake, merge two stakes into one, or end the stake and take everything back, the whole stake at once. None of it has a lock-up or a penalty, and nothing you do to your stake needs anyone’s permission.

The stake is the NFT. Send the NFT to another wallet and the stake, with everything it has not yet claimed, goes with it. The console lists the stakes a wallet holds by asking the Staker, and acts only on those; its Move tab can send one to another wallet, with the receiving address checked first.

AMP is the unit of reward share, and it is not minted one for one. The Staker keeps a running total of the WATT it counts, and the total AMP in existence is the square root of twice that figure. A new stake mints the difference between the total after its WATT is counted and the total before. So the first WATT in the pool earned a great deal of AMP, and each WATT staked today earns less, because the square root flattens as the pool grows.

Two consequences matter when you stake. First, timing: a stake made when the pool is smaller mints more AMP per WATT than the same stake later, and that AMP is kept for as long as the stake stands. Second, the preview: the console asks the contract itself what a given amount would mint, in the block it shows, and prints that figure next to the share of every reward it would give. Ending a stake removes its AMP from the pool and reduces the counted WATT, so the curve steps back for whoever stakes next.

The share shown for a stake is its AMP divided by the AMP of all open stakes. That is the fraction of every future sweep it receives, until the next stake or exit changes the denominator.

The Staker also accepts the WATT/PLS pool token from PulseX, the same pool the console reads for the WATT price. It values an LP token at the pool’s reserves in the block that mines, the WATT side plus the PLS side expressed in WATT, counts one and a half times that value, and mints AMP for the result on the same curve. The LP itself stays in the contract and is returned in full when the stake ends. The pool token comes from adding WATT and PLS to that pool in the PulseX app; app.pulsex.com is a launcher for the app, which is published as an IPFS hash per release, so this page gives no add-liquidity link.

There is no floor on that valuation. If the pool moves between the preview and the block that mines, the WATT figure and the AMP minted move with it, and the console says so in the preview and in the checkpoint before the wallet. A large trade in a thin pool can move it noticeably, and the WATT/PLS pool is thin.

The rewards are not minted. They are fees that other POWERCITY contracts collect and pass on. The treasury holds stakes in the EARN and FLEX staking contracts, the Liquity forks the same community runs consoles for, and those stakes earn the borrowing and redemption fees of the two protocols in PLSX and PXDC, and in HEX and HEXDC. Collector contracts receive them.

A sweep moves the collectors’ contents into the pool. The CollectorHelper has one public function, collect, that asks each collector to distribute what it holds; the Staker records the amount per token and raises every stake’s claimable share at once. Anyone can call it, at any time, and the caller receives nothing but the gas bill. The collectors are not all alike: the EARN and FLEX collectors pass everything they gather, while three others, through which WPLS, PLSX, LOAN, USDL and PXDC have come, keep one third for a split holder at 0x28d1…7760 and pass two thirds. The console shows what a sweep would pass in from every collector, with the split named, in the block it shows, and any connected wallet can send it.

Over 2026 the pool has received a few hundred to a little over a thousand dollars of fees a month at spot prices, depending on how much borrowing and redemption happened on EARN and FLEX. The console sums the last 30 and 90 days from the Staker’s own distribution events and shows the last sweep, so the pace you see is measured, not promised. The contract lists nine tokens it can pay, in this order: WPLS, PLSX, LOAN, USDL, PXDC, HEXDC, HEX, EARN and FLEX; the console’s Fees table shows what each has paid so far, and two of them, EARN and FLEX, had paid nothing when this guide was written. The operator can add a token or switch one off; the list on the console is read from the contract each time.

Claim. One token or all of them, per stake. The contract pays the claimable amount to the wallet that sends the transaction and records it as earned. Claiming does not change the stake or its AMP, and a token the operator has switched off can still be claimed: the switch only stops new distributions of it.

End. One transaction claims every reward the stake holds, returns all of its WATT and LP to your wallet, burns the NFT and removes its AMP from the pool. The console’s checkpoint lists each of those before the wallet opens. It cannot be undone, and it is always the whole stake: the contract has no partial exit, so open more than one stake if you may want to take part out later; for WATT the curve gives several stakes made together exactly the AMP of one, since each mint is the difference of the same square root. Staking again starts on the curve as it stands then.

Merge. Two of your stakes become one: the source’s rewards are claimed, its WATT, LP and AMP move into the target, and the source NFT is burned. The target keeps its own AMP and gains the source’s; nothing is re-minted, so merging never changes your share.

Add. More WATT or LP into an existing stake mints AMP for the addition on the curve and adds it to the stake. The contract accepts an addition to any stake, not only your own; the console offers only the stakes your wallet holds.

Move. The stake is the NFT, and the Staker’s safe transfer sends it to another wallet with every reward it has not yet claimed; whoever holds it then holds the stake, and nothing undoes it. The console’s Move tab asks for the receiving address and, as you type, refuses what must never receive a stake (the zero address, your own wallet, the Staker and the token contracts), checks the checksum, asks a contract the question the chain will ask it (whether it can receive NFTs) and refuses one that cannot, and says what a wallet already holds there, so you recognise your own. The checkpoint shows the full address in groups of four and the rewards that travel with the stake. Send only to a wallet you control: an exchange will not credit a stake NFT.

Before any of these the console shows a checkpoint with the exact amounts and the number of wallet prompts, checks that the stake is still in your wallet at that moment, and afterwards reads the receipt to tell you what happened, in the contract’s own events, rather than what was asked.

The figures below come from the Staker at 0xa42B…0c37. The page you are reading checks them against the contract every time it loads.

Checked against the contract when this page loads; a figure turns green when it matches and amber, with the contract’s own value, if it ever differs.

CORE counts in 18 decimals, the same as WATT and the LP token; three of the reward tokens, HEX, HEXDC and FLEX, have 8. The figures that move, the WATT staked, the AMP of all stakes, the fees paid out and what waits to be swept in, are in the console: Fees and Protocol.

WATT came into being through a migration: holders of the earlier tokens claimed WATT from the Staker with a merkle proof, and the WATT contract mints nothing else. Part of that claim minted stakes directly, and about one seventh of all AMP still belongs to snapshot stakes that were never claimed. The contract still accepts a claim from anyone with a valid merkle proof, once per address; the proof tree lived on the old site, which is offline, so no page has it.

The console shows that reserved AMP in the Stake section so the two totals add up, and says plainly that no page has the proof tree. The reserved AMP is not in the pool: it earns no rewards and takes nothing from yours.

The operator. A 2-of-4 Gnosis Safe at 0x7aaC…080D can add or disable a reward token, replace the NFT metadata contract, replace itself and set the queue delay. It cannot touch a stake, move a reward or pause the contract: a stake or a reward moves only by its holder, or by an address the holder approved on the NFT, and the console’s stake card shows any such approval with its revoke. The delay reads zero seconds on chain, although the documentation promised nine days; a change takes effect the moment the Safe executes it. Disabling a token stops new distributions of it; what stakes already hold stays claimable.

An exit pays every token the stake holds. Ending a stake, merging it, and claiming all of its rewards at once each transfer every listed reward token the stake holds in one transaction, so they depend on each of those tokens accepting a transfer that day. None has ever refused; if one did, that transaction would revert, a stake holding none of that token would be unaffected, and claiming one token at a time would still work. The console says on each stake which applies.

No audit. The documentation lists the audits as pending. The Staker’s source is verified on the explorer and is short enough to read; this guide and the console are built from that source and from the chain, not from the documentation where the two differ.

The pool is thin. WATT trades in one PulseX pool of roughly ten thousand dollars a side. A small trade moves the price, so a dollar figure on the console is a spot reading, marked as such, and never used by a transaction.

The rewards depend on others. Fees arrive only when people borrow and redeem on EARN and FLEX. A quiet month pays little. The console shows the measured pace of the last 30 and 90 days rather than a rate.

LP value moves. An LP stake is valued in the block that mines, with no floor. The console warns before the wallet, and the checkpoint repeats it.

The images are gone. The NFT metadata contract points its images at the old site. Wallets show the stake with a blank picture; the stake itself is unaffected.

The console is a static page with no backend and no account. It reads the chain through public RPC endpoints, asks your wallet to sign only the action you chose, and never asks for a message signature. Every contract it talks to is listed in its footer with an explorer link, and the Verify column there hashes every file the page runs, in your browser, as it was served to you.

The contracts on PulseChain: the Staker, which is also the AMP stake NFT, at 0xa42B…0c37; the CollectorHelper; the tokens WATT and the WATT/PLS LP; the operator Safe. The read-only contracts, the two staking contracts the pending figure comes from and the PulseX pairs the prices come from, are in the footer and in config.js.

The same community runs consoles for the two protocols whose fees feed this pool: earnpulsex.fyi and flexhex.fyi, each with its own guide.

Found a problem, or a question? Write to @DavidDeutschian on Telegram, or to the POWERCITY group.

The official site is gone, and any page that appears in its place sends the same transactions to the same Staker. What separates one front end from another is what the page does around the contracts, and that can be checked from outside in a few minutes.

1. What does the page talk to? Open the browser’s network panel and load the page. Here, every request goes to a PulseChain RPC or to powercitycore.fyi: no analytics, no price API, no fonts from elsewhere, until you connect a phone wallet through WalletConnect. The page is served with a Content-Security-Policy that forbids anything else, and you can read that header yourself. The addresses and checks.
2. How much does it ask you to approve? A stake needs an allowance on the WATT or LP token. Here the checkpoint before the wallet offers two sizes, exactly this deposit by default or the wallet’s balance at that moment, never without limit; the standing allowance is shown in the stake form and can be revoked there with one prompt. The stake form.
3. Does it ever ask you to sign a message? Here the only wallet prompts are transactions to the contracts listed in the footer. A WalletConnect session lists no signing method, and the footer’s Verify column says the same. WATT and the LP token do support permit, an approval given by signature (EIP-2612), but the Staker has no function that takes one, so a permit here would be a signature prompt plus a transaction of its own and would save nothing; the console keeps the plain approval, exactly the amount, and never asks for a signature. The Verify column.
4. Where do its prices come from? Here the market line names the PulseX pool it read, the pool addresses sit in config.js and under Read only in the footer, and the same reserves can be read on the explorer. Prices are for display only; no transaction uses them. The market line.
5. Is the page you got the page that was published? Here the Verify column hashes every file the page runs, in your browser, as it was served to you. Compare with curl -s https://powercitycore.fyi/app.js | sha256sum, or with a friend’s screen. The same files are also published on IPFS under the domain’s name: dig TXT _dnslink.powercitycore.fyi names the release, ipfs ls and ipfs get read it, each file equals the one the domain serves under the same path, and ipfs add -r --cid-version=1 --only-hash over that directory gives the record’s hash back. The file hashes.
6. Where do the explorer links go? Here, to scan.pulsechain.com. Hover any address in the footer. The addresses.

Run the same six on any front end that is new to you. Sites change, so what a page does today is the only thing worth relying on.

Before a release, the community runs on the exact files: a walk of the page through forty-two wording states at seven widths, every figure and every line of copy asserted; a read-only run of the page against the chain; and, for any change to a transaction path, a rehearsal of every transaction on a fork of the chain, eighteen phases. After each deploy: the served headers, the page’s chain facts against the chain, and the mirror’s root hash, rebuilt from the served files, against the DNS record. On every push the repository pins the served files on IPFS and moves the domain’s name to the new release only when the pinned hash equals the hash computed from the committed files. The checks and their runners live in the repository, not on the site, so this paragraph is a claim to hold the console to, not proof; the six checks above are what you can see for yourself.