Revolutionary creator fee cycling system built on pump.fun, ensuring every holder receives rewards through deterministic round-robin distribution.
View Live DistributionBuilt on pump.fun's new share system with deterministic, verifiable distribution mechanics
Deterministic selection mechanism ensuring each holder receives fees exactly once per complete cycle. No holder is selected twice until all holders have been rewarded, guaranteeing perfect equity across the entire holder base.
Automated distribution triggers every 300 seconds. Each interval selects the next sequential group of 10 holders from the queue, maintaining precise temporal consistency and predictable reward schedules.
Cryptographically verified holder sequence established at cycle initialization. Queue position is immutable and verifiable on-chain, preventing manipulation and ensuring transparent ordering mechanisms.
Native integration with pump.fun's creator fee infrastructure. Leverages the new share system to programmatically distribute accumulated fees according to the round-robin protocol specifications.
Upon cycle completion, the system automatically reinitializes with an updated holder snapshot. New holders are appended to the queue, maintaining historical position priority while integrating new participants seamlessly.
All distribution events are recorded on Solana with verifiable transaction hashes. Smart contract state provides real-time proof of fair distribution, enabling independent audit and validation of protocol mechanics.
Real-time visualization of the current 5-minute reward distribution cycle
How share.fun ensures equitable fee distribution across all holders
At the start of each cycle, the protocol captures a complete snapshot of all token holders. Each holder is assigned a sequential position in the distribution queue based on chronological order of token acquisition.
Every 5 minutes, the protocol selects the next 10 holders from the queue. Selection is deterministic and sequential, advancing through the queue in strict order without randomization or prioritization.
Accumulated creator fees from pump.fun are distributed equally among the 10 selected holders. Distribution occurs via smart contract execution, ensuring atomic transactions and verifiable on-chain settlement.
Each holder who receives fees is marked as "completed" for the current cycle. The protocol maintains immutable records of all distributions, preventing duplicate payments and ensuring single-cycle participation.
The distribution pointer advances to position 11-20 for the next interval. This process continues sequentially through the entire holder list, maintaining strict chronological order throughout the cycle.
Once all holders have received their distribution, the cycle automatically resets. A new snapshot is taken, incorporating any new holders while preserving the position of existing holders, and the process begins again.
Core distribution algorithm implementation
// Round-robin fee distribution protocol
contract ShareFunDistribution {
struct Cycle {
uint256 id;
address[] holders;
uint256 currentIndex;
uint256 lastDistribution;
bool active;
}
Cycle public currentCycle;
uint256 constant BATCH_SIZE = 10;
uint256 constant INTERVAL = 300; // 5 minutes in seconds
function initializeCycle() internal {
address[] memory snapshot = getHolderSnapshot();
currentCycle = Cycle({
id: currentCycle.id + 1,
holders: snapshot,
currentIndex: 0,
lastDistribution: block.timestamp,
active: true
});
}
function distributeToNextBatch() external {
require(block.timestamp >= currentCycle.lastDistribution + INTERVAL,
"Interval not elapsed");
require(currentCycle.active, "Cycle not active");
uint256 endIndex = min(
currentCycle.currentIndex + BATCH_SIZE,
currentCycle.holders.length
);
// Distribute fees to current batch
for (uint256 i = currentCycle.currentIndex; i < endIndex; i++) {
distributeFees(currentCycle.holders[i]);
}
currentCycle.currentIndex = endIndex;
currentCycle.lastDistribution = block.timestamp;
// Reset cycle if all holders processed
if (currentCycle.currentIndex >= currentCycle.holders.length) {
currentCycle.active = false;
initializeCycle();
}
}
function getNextBatchTimestamp() public view returns (uint256) {
return currentCycle.lastDistribution + INTERVAL;
}
}