Under the hood

The BARS Reflex Engine.

The protocol maintains a live record for every wallet that has ever held the token. Each record captures three things: what they hold, how they earned their tier, and whether they're eligible right now. There is no 'trust us.' There is the chain, the rules, and the log.

State · 01

Holders

Balances are the live state — updated every snapshot from the chain. Conviction is what makes the system fair: your baseline is locked at the lowest price you've ever been observed at, not today's price. A pump doesn't promote you to a tier you didn't earn — a dip doesn't punish you for earlier buys.

Tier classification is computed, not assigned. Class is determined by retention vs real cost. Tier is determined by effective dollar buy-in. Both recomputed every cycle. Eligibility is the on/off switch: clear the buy-in floor, stay un-flagged. Audit preserves the snapshots that matter.

holders

identity

└ wallet
└ first_seen_at

balances

└ current_balance
└ peak_balance
└ initial_balance
└ accrued_rewards

conviction

└ original_buy_in
└ min_price_seen_usd
└ obi_baseline_usd
└ obi_baseline_mcap
└ first_qualified_at

tier_classification

└ holder_class
└ holder_tier
└ class_updated_at

eligibility

└ min_buy_in_qualified
└ min_buy_in_qualified_at
└ min_buy_in_qualified_value
└ disqualified

audit

└ first_seen_market_cap
└ first_seen_price_usd
└ dq_market_cap
└ dq_price_usd

Flow · 02

How rewards flow

The protocol claims, swaps, and distributes on a fixed cycle. Every step is logged and signed. Each cycle moves through four states: claimed → bought → sent → complete. Every transition is timestamped and tied to a transaction signature you can verify on Solscan.

Step 1

claimed

Step 2

bought

Step 3

sent

Step 4

complete

distribution_cycles

cycle

└ id
└ started_at
└ completed_at
└ state

claim

└ claim_signature
└ claimed_sol
└ claimed_usd

swap

└ swap_signature
└ swap_in_sol
└ swap_out_tokens

airdrop

└ airdrop_signature_set
└ recipient_count

rewards_ledger

receipt

└ id
└ cycle_ref → distribution_cycles
└ wallet → holders

amount

└ amount_tokens
└ share_pct

delivery

└ status
└ tx_signature
└ created_at
└ sent_at

cycle_events

step

└ id
└ cycle_num
└ step
└ status

└ tx_signature
└ amount_sol
└ amount_tokens

The social rewards pool

A portion of every cycle's rewards isn't paid out directly — it's added to a persistent pool that holders can claim from by sharing about the project. Anything unclaimed in a period rolls forward. Doesn't disappear. Doesn't claw back to the treasury. Doesn't dilute. It waits for the next claimer.

share_pool · share_periods · share_claims

share_pool

└ current_balance
└ total_added_lifetime
└ total_claimed_lifetime
└ last_period_carryover
└ current_period_start_at

share_periods

└ id
└ period_start_at
└ period_end_at
└ amount_added
└ amount_claimed
└ carryover_in
└ carryover_out

share_claims

└ id
└ wallet → holders
└ post_url
└ amount_tokens
└ tx_signature
└ status
└ requested_at
└ distributed_at

Every claim is tied to a verifiable post URL and an on-chain transaction. No anonymous payouts.

Events · 04

Milestone payouts

When market cap hits a configured threshold, an additional distribution fires on top of the normal cycle. Each milestone is hit exactly once. Dips back below don't re-trigger; subsequent crosses don't double-pay.

milestone_log

milestone

└ milestone_threshold
└ hit_at
└ market_cap_at_hit

distribution

└ distributed_amount
└ eligible_holder_count
└ distribution_tx

Enforcement · 05

Edge cases & second chances

Flagging is automatic and rule-based: same IP submitting from many wallets, posts that don't pass verification. Once flagged, a wallet can submit a comment through the forgiveness portal explaining the situation. Decisions are logged with the reviewer's notes — nothing happens in DMs.

flagged_wallets · forgiveness_log

flagged_wallets

└ wallet
└ reason
└ flagged_at
└ ip

forgiveness_log

└ id
└ wallet → holders
└ comment
└ status
└ submitted_at
└ reviewed_at
└ reviewer_notes

System · 06

How it all fits together

holders ──┬──< rewards_ledger >── distribution_cycles
          ├──< share_claims
          ├──── flagged_wallets
          └──< forgiveness_log

share_pool ──< share_periods

distribution_cycles ──< cycle_events
                    ──< milestone_log

Every payout in rewards_ledger ties back to a holder and a specific cycle. Every cycle has a complete event trail. Every share claim ties back to a holder and a verifiable post. Every flag has a reason. Every forgiveness request has an outcome.

Read the whitepaper See the roadmap