SitowiseNode states
A node is either active or retired. Both are rows in the operator’s database, not fields in the contract, and the distinction decides one thing only: whether the node is included in new distribution rounds. It has no effect on value already credited to it.
The two states
| State | Included in rounds | Can withdraw | Reversible |
|---|---|---|---|
active | Yes | Yes | Not applicable |
retired | No | Yes, for everything already credited | Only by the operator, and it is not routine |
A node is active from the moment mintFor creates it on chain. There is no activation step, no waiting period, and nothing to configure.
State lives off chain, and that is deliberate
The factory has no status field. A node is a struct holding an owner, a creation timestamp, a balance and two running totals, and none of those is a state machine. The state you see in the dashboard comes from the operator’s ledger, where it is a column on the node row:
status text not null default 'active'
check (status in ('active','retired'))The consequence is the important part: because the contract does not know about the state, the state cannot stop you withdrawing. withdraw consults two things, the node’s owner and the node’s balance, and both are on chain.
There is also nothing in the contract that ends a node. No retirement function, no burn, no expiry, and no admin call that deletes one. A node exists from the moment it is created and keeps existing; the only thing that ever changes about it without the owner acting is its balance going up when a round credits it.
What causes retirement
Retirement is an operator action in the ledger, not something a holder triggers and not something that happens on a timer. In normal operation it is used for one thing: excluding a node from rounds when it should no longer receive new credits, for example a node created during testing or one involved in an abuse investigation.
It is not a punishment mechanism aimed at holders, and it does not exist to claw back value. It cannot claw back value: retiring a row in a database does not move ETH out of a node balance, and the contract offers no call that would.
Withdrawing does not change state
Withdrawing is not an exit. It sets the node’s balance to zero, adds the same amount to its totalWithdrawn, and sends the ETH. The node carries on exactly as before, with its totalReceived intact as the record of everything it has ever earned. An active node that has withdrawn everything credited to it is still active and still included in the next round.
This is why the lifecycle diagram has a loop on both live states rather than an arrow leading out. There is no state that a withdrawal moves you into.
Pausing is the one operator switch that touches the contract, and it does not touch this either. setPaused(true) stops new nodes being created and nothing else; there is no code path in which a pause blocks a withdrawal. See Limits.
Reading the state
The dashboard shows it per node. Over HTTP it is on the node record returned by GET /api/node/:id and in the list from GET /api/nodes/:address.
On chain there is no state to read, because there is none there. What you can read on chain is what actually governs your money:
cast call $FACTORY "nodeInfo(uint256)(address,uint64,uint256,uint256,uint256)" $NODE_ID
# -> owner, createdAt, balance, totalReceived, totalWithdrawn
cast call $FACTORY "balanceOfOwner(address)(uint256)" $WALLETIf the owner and the balance are what you expect, your position is what you expect, whatever any interface says about state.