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.

CreditKeeping the seat

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.