Fees and the dev share

Every claim is split the same way, in this order. The shares are settings you can read, and each split is a line in the journal.

The order

1. The dev share. creatorSharePct of the claim is set aside for the dev address. With the launch page's defaults that is 50%.
2. Of the rest, the battery. batterySharePct (30% by default) of what is left charges the battery, in dollars.
3. The treasury. What is left after that is the ETH the hooks may burn.

With a 2% coin fee and the defaults

Pons takes the coin's creator fee on every trade and pays it to the organism wallet. For each 100 ETH traded, a 2% fee is 2 ETH:

The launch page shows this breakdown live as you move the sliders, and the home page shows it as a bar.

Two ways to run it

• Your own wallet (the usual one). You launch the coin on Pons yourself; the organism runs with the key of that same wallet. The dev share is left where it is: never moved, never spent. The ETH the wallet already holds and the tokens of your dev buy are never touched: burns are paid only from the project's own share of the fees that arrived after the start, and the tokens they buy go straight to the burn address. The Pons escrow is one balance for all the coins a wallet receives fees for, so the organism claims only what arrived after it started; what was already there (earlier fees, other coins) stays untouched in the escrow. The project pays the gas of its own transactions out of its share.
• A separate wallet. The launch page can make a new wallet and launch the coin with it as recipient. Then the dev share is sent to the dev address you set (creatorAddress), as described below.

The dev share, in detail (separate wallet)

• One address. creatorAddress in organism.json. It is published in status.json and shown on the coin page.
• Only that address. The live executor is started with that address as its only allowed payee. Asked to pay anyone else, it refuses, whatever the engine requests.
• When it is paid. The share accumulates as owed, set aside and out of the treasury, until it reaches minPayoutEth (0.0005 ETH). Then one transfer is sent and a PAYOUT line with the transaction hash is written. Below the minimum nothing is sent, so there are no dust transfers.
• If a transfer fails. The amount stays owed and is retried at the next beat. Nothing is lost and nothing is spent in the meantime: the treasury cap excludes the owed amount.
• If the receipt is lost. A transfer can be mined while the answer never arrives. The wallet balance before and after decides: if it dropped by the amount, the payout is counted as sent. If the balance cannot be read either, the amount stays owed and is retried. In that rare case a second transfer can go through, so one payout can be sent twice. It is bounded to one payout, goes to the same address, and comes out of the wallet, never past the gas reserve.
• What Verify checks. Each recent payout is re-read from its transaction: success, sent to the published dev address, for the amount the journal says. It also compares the share of claims the journal gives to the dev with the published percentage.

What the dev share is, and is not

It is a share of the fees, taken before the coin gets any of it, and it is public. A holder can see it in the settings, in every CLAIM line, in every PAYOUT line, and on the chain. It is not hidden, and it is not paid from anything but the fees.

It is not a promise about the coin: the dev share does not depend on the price, and the coin's holders should weigh it like any other fee that does not go to the burn.

Set it to 0 and nothing is paid: the whole claim is split between the battery and the treasury. There is no payout address in that case, and the wallet then sends ETH nowhere except through the exit.

Changing it

Edit creatorSharePct and creatorAddress in organism.json and restart. A share above 0 needs a valid address (not the zero or burn address), and the share cannot exceed 90%. The settings are validated before anything runs.