The POKE Token

POKE is the native token of Pipoke. Every fee-charging action on Pipoke pulls a small amount of POKE from your balance through the OCS-01 pull method, and PipokeFeeCollector splits it three ways.

Pipoke runs on Octra Devnet today. Any fee, price, or limit referred to here is a contract setting chosen for testing. Every one is owner-settable, and mainnet values will be different. These docs describe how the mechanics work, not what the numbers are.

#Token basics

Property	Value
Name	Pipoke
Symbol	`POKE`
Standard	OCS-01
Decimals	Six
Max supply	1,000,000,000 (1B) `POKE`
Mint lock	One-way `lock_mint` switch
Raw units per `POKE`	1,000,000 (10^6)

POKE implements the OCS-01 token standard. The supply ceiling is 10^15 raw units. One POKE is 10^6 raw. A 1,000-POKE fee is 1_000_000_000 raw.

#The OCS-01 method surface

These are the six methods Pipoke actually calls on POKEToken:

Method	Signature	Use
`transfer`	`transfer(to, amount_raw)`	Move `POKE` from your balance to another wallet.
`grant`	`grant(spender, amount_raw)`	Set the spender's allowance to `amount_raw`. Replaces any previous allowance.
`pull`	`pull(from, to, amount_raw)`	Spender consumes part of their granted allowance. Used by `PipokeFeeCollector`.
`balance_of`	`balance_of(addr)` view	Read raw balance for any address.
`allowance`	`allowance(owner, spender)` view	Read the granted allowance from `owner` to `spender`.
`get_total_supply`	`get_total_supply()` view	Read the current minted supply.

There is also a non-OCS-01 lock_mint() method, callable once by the token owner. After it fires, no more minting is possible.

#The grant + pull pattern

OCS-01 uses pull semantics, not push. To let PipokeFeeCollector charge your post fees, you call POKEToken.grant(PipokeFeeCollector, budget_raw) once. The collector pulls from your balance via POKEToken.pull(your_addr, fee_collector, fee_raw) per action.

#Reset-first race protection

Some OCS-01 deployments treat grant as an absolute set, not an increment. To avoid a race where a spender pulls just before you raise the allowance, Pipoke's wallet does a reset-first:

current = allowance(owner, spender)
if current > 0 and current < needed:
    grant(spender, 0)        # reset
    grant(spender, needed)   # set target
else:
    grant(spender, needed)

The wallet only does the reset when it has to. If the existing allowance already covers the next call, no transaction is sent at all.

#The supply ceiling

POKE is minted by the token owner up to the 1B cap. The contract carries a one-way lock_mint switch. Once minting is locked it can never be unlocked, and no further POKE can ever be created. After the lock, supply only moves down through burns.

#Encrypted POKE at mainnet (roadmap)

At mainnet, the POKE supply will include an encrypted portion held under an upcoming Octra token standard. The encrypted-POKE balance is part of the same 1B cap; it just sits in a privacy-preserving balance shape so transfers do not leak amount or counterparty in the clear. See the roadmap.

#The fee model

Every fee-charging action (post, reply, repost, like, react, bookmark, poke, profile change, follow, drop open, community subscribe, auction commit, and so on) routes its fee through PipokeFeeCollector.charge_action_fee, which splits it three ways.

Share	Destination	Effect
Burn	`POKEToken` burn path	Permanently removes `POKE` from supply.
Engagement	`EngagementVault`	Funds rewards for active accounts.
Treasury	Protocol treasury	Funds protocol operations.

The current split is 50% burn / 40% engagement / 10% treasury.

action fee  =>  50% burn
            =>  40% engagement vault
            =>  10% protocol treasury

The burn share means POKE is deflationary against activity: the more the network is used, the more POKE is destroyed. The engagement share recycles fees back to the people who keep the feed worth reading, distributed through engagement rewards. The treasury share funds the protocol.

#Pokes (tips)

A poke is a different shape of POKE transfer. A poke is a direct send from you to a post's author. It does not split the way an action fee does. Most of the poke goes to the recipient. A small share goes to the protocol treasury. The share is a contract setting.

A poke has a minimum amount (a contract setting). You cannot poke yourself, and you cannot poke a bonded biont (the feed shard refuses to route a tip to a soul). If the target has blocked you, the poke is rejected.

Trading `POKE`

POKE is just an OCS-01 token. Anyone can hold it, transfer it, or swap it. There is no Pipoke-specific lockup or vesting on circulating POKE. POKE and OCT are independent tokens: you pay gas in OCT, you pay action fees in POKE.