An ERC-721 token is a number in a mapping. tokenId → owner. It has an owner, it has metadata pointing at a picture, and that is the whole of it. It cannot hold a balance. It cannot sign anything. It cannot be sent a payment.

So when a collection says its NFTs "earn", something else is doing the earning. A separate contract keeps a list of which address held which token at which block, and pays the addresses on that list. The token is a ticket stub. The money never touches it, and the moment the project stops running that list, the token goes back to being a picture.

Ink Brokers is built the other way round. A broker is not a ticket stub — it is a desk with a drawer. It holds its own assets, it signs its own transactions, and when it changes hands the drawer goes with it. This is how that works, and what it costs.

The primitiveA broker is an account

The mechanism is ERC-6551, "Non-fungible Token Bound Accounts". It changes nothing about ERC-721 — no new token standard, no migration, nothing a wallet or a marketplace has to learn. It adds one permissionless singleton contract, the registry, which lives at the same address on every chain that has it: 0x000000006551c19487814612e58FE06813775758.

That address is not assigned by anyone. The registry is deployed deterministically — same bytecode, same salt, through the standard deterministic deployment proxy — so it lands on that address on any EVM chain, and anybody can be the one who deploys it. Which means the address is identical everywhere it exists, and absent everywhere nobody has bothered. Check before you assume; a chain without the registry has no token bound accounts on it at all.

Two functions matter.

function createAccount(
    address implementation,
    bytes32 salt,
    uint256 chainId,
    address tokenContract,
    uint256 tokenId
) external returns (address account);

function account(
    address implementation,
    bytes32 salt,
    uint256 chainId,
    address tokenContract,
    uint256 tokenId
) external view returns (address account);

account() computes an address. createAccount() deploys the contract that lives at it. The address comes out of CREATE2, which makes it a pure function of those five inputs — an implementation, a salt, and the token's full identity: chain, contract, id. Feed the same five in and you get the same address, every time, on any chain, whether or not anything has been deployed there yet.

That last clause is the useful part. Because the address is computable before deployment, a broker can receive assets before its account exists. Send tokens to broker #1234's account on day one and deploy the account on day ninety — the funds were sitting the whole time at an address only #1234's holder can ever control. The spec calls these counterfactual accounts, and they are the reason none of this needs a "claim your wallet" step.

The deployed account is an ERC-1167 minimal proxy with the salt, chain id, token contract and token id appended to its bytecode as immutable data. The account knows which token it belongs to, permanently. When something asks whether an address may sign for it, the account looks up who owns that token right now. The spec is blunt about it:

By default, the holder of the non-fungible token the account is bound to MUST be considered a valid signer. ERC-6551 §Account Interface

There is no update step on transfer. No migration, no re-registration, no admin key. Sell the broker and the buyer controls the drawer the moment the transfer confirms — because control was never stored anywhere to begin with. It is recomputed, every call, from ownership.

ActivationClocking in

A minted broker sits there. It has an account, it has traits, it trades — and it earns nothing, because the desk does not know it exists. Activation is the transaction that puts it on the floor. It does three things: burns tokens, writes the broker into the active set, and fixes the tier.

The burn is worth being precise about. It is not a fee routed to a treasury that promises a buyback later. The tokens go to an address nobody controls, and total supply drops. Every broker that clocks in makes the remaining supply permanently thinner, and there is no function on the other side that mints them back.

That is a design choice with a consequence attached, and it cuts both ways. It means activation is the one lever the project has that costs the project nothing and costs the participant something real — which is exactly why it has to be worth doing on the arithmetic alone. If the rounds do not justify the burn, nobody clocks in, and no amount of announcing changes that.

TiersThe ladder

Tier is the second thing activation fixes, and it is not for sale.

Every broker is scored on the rarity of what it rolled, using standard rarity scoring: for each of the ten trait slots, take the reciprocal of how often that trait occurs across the collection, then sum the ten. Four common traits score low. A 2% headpiece next to a 3% background scores high. All 4,444 are ranked against each other and cut at fixed percentiles.

Weight is relative, not absolute. A T4 does not receive sixty payouts — it receives sixty shares where a T0 receives one, out of whatever the round actually contains. Sixty times nothing is still nothing.

Two properties fall out of scoring it this way, both intentional. Tier is knowable before you buy: the ranking is a pure function of the collection, so any token's tier can be checked in the generator before a single transaction. And tier is fixed at activation — it does not drift when other people clock in later, so a T3 activated on day one is still a T3 on day four hundred.

DistributionsThe round

Rounds are pull, not push, and that is not a stylistic preference.

The naive design is a loop: iterate every active broker, send each its share. It works at fifty and dies at four thousand. Gas grows with the set until the transaction will not fit in a block, and a single recipient whose contract reverts on receive takes the whole distribution down with it.

So rounds are accounted rather than disbursed. When a round opens, the desk records two numbers: the amount, and the total active weight at that instant. Every broker's share is arithmetic against that snapshot, and the holder claims it whenever they want. Nothing iterates. Nothing can be bricked by one bad recipient. Gas is paid by whoever collects, at the moment they collect.

The consequence you should hear alongside that: a round pays what the desk collected. Not a rate, not a yield, not a projection. If the desk collected nothing that week, the round is zero, and every tier gets its weighted share of zero. No mechanism described here creates money — all of them split fees that were actually paid by someone.

LiquidityThe counter

Selling an NFT normally means waiting for a bid. An NFT AMM removes the wait by pairing the collection against a token in a pool that runs a bonding curve. Deposit tokens, take a broker out. Deposit a broker, take tokens out. The price walks along the curve with every trade — each broker pulled from the pool makes the next one dearer, each one sold back makes the next one cheaper.

What that buys is a bid that is always there and an ask that is always there, quoted by arithmetic instead of by whoever happens to be online at 3am.

What it costs is discrimination. The curve does not care which broker you hand it: to the pool, a T4 and a T0 are the same object. Pools like this quote floor, and nothing above floor can be captured by selling into one. That is not a flaw to be fixed — it is the trade. An orderbook marketplace answers the other question, "what is this specific broker worth to a specific person", and the two are meant to coexist.

Worth putting a number on it, because the prose hides how large the gap is. The counter's bid opens at 75,000 tokens for any broker. Hand it one of the 89 Partners — a seat carrying 60× an Intern's share of every round — and it pays exactly what it pays for one of the 2,755 Interns. Nor is the mistake a race somebody might win: buy serves last in, first out, so a rare broker sold into the pool is handed deterministically to the next person watching.

The terminal refuses to let that happen quietly — entering a broker above the base tier on the Sell panel raises a red block naming the tier, its weight and the sum, and the button has to be pressed a second time. But the contract does not know about tiers and never will, so the honest summary is this: the counter is where you sell a broker for the floor, on purpose. If you want more than the floor for a rare one, list it instead.

TokenomicsThe token

$INKBROKER has no allocation. There is no claim, no airdrop and no presale; the treasury was issued nothing, and the only way anyone holds a token is by buying it. That is unusual enough to be worth stating before the numbers, because it is what the numbers are shaped around.

Supply is not a round marketing figure. It is the collection priced at the counter's opening bid — 75,000 × 4,444 = 333,300,000 — so one broker is a fixed slice of the supply rather than a number someone picked. Every token had a job before launch:

An earlier draft carried a 25% reserve with nothing to do. It was not burned for a headline — it was simply never minted, which is the same outcome with one less step and one less thing to promise about.

The burn is the only sink

Clocking in destroys tokens. The amount is 7,500 + 375 × weight, so it is priced against the share of the flow it buys:

Share is of a round with the whole collection working (total weight 19,654). With fewer seats active, each one is worth proportionally more.

If every broker clocked in once, that destroys 40,700,250 tokens — 12.21% of supply. And it is recurring rather than one-off: a seat ends when its broker leaves the holder's wallet, so every resale burns again for the next holder. There is no other mechanism that reduces supply, and no mechanism at all that increases it — the mint function does not exist after deployment.

Worth being straight about the shape of that ladder: weight spans 60× from Intern to Partner, while price spans only 3.81×. A Partner is the better deal per token burned, by a wide margin. That is deliberate — the flat part of the cost is what makes the sink large, because most of the collection is T0 — but it is not proportional, and nobody should read it as such.

Where the pay comes from

Not from printing. The pool charges 1.5% on every swap, taken in whichever currency the trade came in as — buying pays in ether, selling pays in tokens — so working brokers are paid in both. The stream is divided at a ratio fixed when the contracts were deployed:

The splitter has no owner and no setters. Both destinations and the ratio are immutable — not "governed", not "timelocked", simply absent from the contract. Nobody can redirect that stream, including whoever deployed it.

What "locked" means, precisely

The liquidity position lives in a contract with no owner, no pause, no upgrade path and no withdrawal function. The only call it can make into Uniswap is a liquidity decrease of a literal zero — the number is written into the source as a constant, so extraction is impossible rather than merely unauthorised. There is no approve, no transferFrom, and deliberately no signature-verification function, because that last one would let Uniswap's permit flow hand someone authority over the position.

So the principal is unreachable. Fees are the only thing that ever comes out, and they go to the splitter above. This is checkable, not a promise:

The counter is a different thing and is not locked. It is our own market maker: the owner can withdraw its float and any brokers it has taken in. Saying "the liquidity is locked" without that sentence would be misleading, so here it is. The locked claim describes the Uniswap position, and only that.

What this does not promise

Rounds pay what the desk collected. Quiet trading pays little; no trading pays nothing. No tier weight multiplies an empty round into a full one, and there is no yield here that does not come out of somebody else's trade. The burn reduces supply, but 12.21% across the whole collection is a sink, not an engine — what moves this is volume, and volume is not something we can promise.

CreditKeeping the seat Soon

Selling a broker to raise cash means giving up the tier and every round that comes after it. A loan against the broker is the alternative: the token moves into an escrow contract as collateral, the borrower takes liquidity out, and the position stays intact while the loan is open.

The honest framing is that this is a leveraged position, not free money. If the collateral's value falls under the threshold the loan was written at, the broker is liquidated. And unlike a sale, which you time, liquidation arrives at the worst possible moment by construction — the trigger is the price falling. A loan is the right instrument when you are confident in the seat and need cash for something unrelated to it. It is the wrong instrument for buying more seats.

Failure modesWhat can go wrong

Every mechanism above has a way to hurt you. Describing something clearly does not make it safe, so here is the list without the marketing voice.

In closingThe shift

None of the above is exotic. Token bound accounts are a two-function registry. Rarity ranking is a sum of reciprocals. Pull-based distribution is the oldest fix in Solidity for a loop that does not scale. A bonding curve is arithmetic.

What is unusual is putting them in one place and having the thing that holds the money be the same thing you can look at. A broker is not a receipt for a position kept somewhere else. It is the position. That is the entire argument, and everything above is the plumbing that makes it true.

The floor opens on Ink. The bell never rings.