SHAREHOLDERS VIEW DISTRIBUTIONS
The $SHAREHOLDER mission-control mascot
SHAREHOLDER #000001

Now, you're
a shareholder.

VIEW DISTRIBUTIONS ↘
MINIMUM HOLD100K $SHAREHOLDER
REWARD ASSETSPCX · ONDO
EXECUTIONAUTOMATIC
SYNCING…
Total Fees Earned
0.00SOL
all-time · ≈ $0.00
SPCX Shared to Holders
0.0000SPCX
sent out · ≈ $0.00
Holders Rewarded
0UNIQUE
received SPCX
SPCX Price
$0.00
Ondo tokenized SpaceX
/ TOKEN ADDRESSES
TOKEN · $SHAREHOLDER— NOT LIVE YET —
REWARD · SPCX (ONDO)SPCXxcqXj6e5dJDVNovHN8744zkbhM2bYudU45BimGb
/ THE LOOP

Four procedures.
One very serious little machine.

The keeper turns fees into an on-chain reward loop. It does the accounting so the flight director can stare intensely at the sky.

[ 0 ]
Claim
Creator fees accrue in a vault. The keeper sweeps them once they clear the configured threshold.
[ 1 ]
Buy
It routes the fees through Jupiter and buys SPCX at the best available price.
[ 2 ]
Snapshot
A holder snapshot is taken; pools, vaults and protocol accounts are excluded before weights are computed.
[ 3 ]
Reflect
SPCX is sent to every eligible holder by weight, idempotently, with a proof trail on-chain.
/ DISTRIBUTION LOG

Every reflection,
on the record.

Each row is a distribution of Ondo's SPCX to $SHAREHOLDER holders. The money is funny. The receipts are not.

VERIFIABLE
ON-CHAIN
RECEIPTS
NO DISTRIBUTIONS YET — THE FIRST REFLECTION WILL APPEAR HERE AUTOMATICALLY.
/ THE ENGINE

Logic,
in the open.

claimCreatorFee.ts[ 0 ] CLAIM
// Creator fees accrue in an on-chain vault — they are not auto-sent.
// Read what's claimable; only sweep once it clears the threshold.
const { distributable, canDistribute } = await sdk.getDistributableFee(mint);
if (distributable < CLAIM_THRESHOLD || !canDistribute) return;

const ixs = await sdk.buildDistributeFeeInstructions(mint);
const sig = await sendAndConfirm(ixs, keeper);
// 80% of the claim funds buyback, 20% is held back for gas + rent.
recordClaim(distributable, BUYBACK_FRACTION);
buyback.ts[ 1 ] BUY SPCX (ONDO)
// Spend ONLY the claimed-fee budget — wallet principal is never touched.
const budget = feeBudget() - reserveForGasAndRent(newAtas);
if (budget <= 0n) return;

const quote = await jupiter.quote({
  inputMint: SOL, outputMint: SPCX,
  amount: budget, slippageBps: SLIPPAGE,
});
const tx = await jupiter.swap(quote);
if (tx.feePayer() !== keeper) throw "refusing to sign";
await sendAndConfirm(tx);
// distribution uses the ACTUAL SPCX received, not the quote.
const bought = await balanceDelta(spcxAccount);
distribution.ts[ 2 ] SNAPSHOT + WEIGHT
// Full on-chain holder snapshot, cross-checked against supply.
const holders = await snapshotHolders(meme);
assertWithinSupply(holders);  // reject injected/poisoned balances

let totalEligible = 0n;
for (const h of holders) {
  // pools, the bonding curve, fee vaults & the keeper are excluded
  if (isExcluded(h) || h.balance < MIN_HOLD) continue;
  totalEligible += h.balance;
}
for (const h of eligible) {
  h.share = bought * h.balance / totalEligible;  // pro-rata
}
transfer.ts[ 3 ] REFLECT
// Idempotent batched transfers — a crash or retry never double-pays.
for (const batch of chunk(eligible, BATCH_SIZE)) {
  const ix = [];
  for (const r of batch) {
    if (ledger.isSent(r.owner)) continue;   // already paid
    if (await isFrozen(r.owner)) continue;    // skip poisoned ATAs
    ix.push(createAtaIfMissing(r.owner));
    ix.push(transferChecked(r.owner, r.share));
  }
  const sig = await sendAndConfirm(ix);
  ledger.markSent(batch, sig);   // on-chain proof, replay-safe
}