​
E-Commerce Store

Transform customer purchases into token utility with automatic burns and loyalty rewards.

​
Business Model

  • Trigger: Customer purchases products
  • Actions: Burn tokens (reduce supply) + Airdrop loyalty tokens to customer
  • Result: Increased token scarcity + Customer retention through rewards

​
Implementation

// Register flywheel (one-time setup via web app)
// Configuration done at https://believe.app/projects:
// - Token: ecommerce_token_123
// - Wallet: store_owner_wallet_address
// - Daily Burn Limit: 50,000 tokens
// - Daily Airdrop Limit: 25,000 tokens
// - Scopes: burn, airdrop
// - Proof Types: PRODUCT_PURCHASE, BULK_ORDER

// After registration, you'll receive:
const flywheelApiKey = "your_api_key_from_web_app";
const vaultAddress = "your_vault_address_from_web_app";

// Handle individual purchase
async function processPurchase(order) {
  const burnAmount = Math.floor(order.total * 10); // 10 tokens per $1
  const rewardAmount = Math.floor(order.total * 5); // 5 tokens reward per $1

  const pipeline = {
    type: "PRODUCT_PURCHASE",
    payload: JSON.stringify({
      orderId: order.id,
      customerId: order.customerId,
      total: order.total,
      products: order.items.map((item) => ({
        id: item.productId,
        quantity: item.quantity,
        price: item.price,
      })),
      timestamp: new Date().toISOString(),
    }),
    actions: [
      { action: "BURN", amount: burnAmount },
      {
        action: "AIRDROP",
        toAddress: order.customerWallet,
        amount: rewardAmount,
      },
    ],
  };

  return await executePipeline(pipeline);
}

// Handle bulk orders with higher rewards
async function processBulkOrder(order) {
  if (order.total < 1000) return processPurchase(order); // Use regular flow

  const burnAmount = Math.floor(order.total * 12); // Higher burn rate
  const rewardAmount = Math.floor(order.total * 8); // Higher reward rate

  const pipeline = {
    type: "BULK_ORDER",
    payload: JSON.stringify({
      orderId: order.id,
      customerId: order.customerId,
      total: order.total,
      bulkDiscount: order.discount,
      timestamp: new Date().toISOString(),
    }),
    actions: [
      { action: "BURN", amount: burnAmount },
      {
        action: "AIRDROP",
        toAddress: order.customerWallet,
        amount: rewardAmount,
      },
      { action: "MEMO", message: `Bulk order bonus: ${order.total}` },
    ],
  };

  return await executePipeline(pipeline);
}

​
Expected Results

  • Token scarcity increases with every purchase
  • Customer loyalty grows through token rewards
  • Community can fund the vault to increase reward capacity
  • Transparent operations build trust with customers

​
Gaming Platform

Reward player engagement while managing token inflation through strategic burns.

​
Business Model

  • Trigger: Player achievements, level-ups, tournament wins
  • Actions: Burn tokens for major achievements + Airdrop rewards for engagement
  • Result: Deflationary tokenomics + Sustained player engagement

​
Implementation

// Flywheel configuration for gaming (set up via web app)
// Configuration at https://believe.app/projects:
// - Token: game_token_456
// - Daily Burn Limit: 100,000 tokens (high limit for active gaming)
// - Daily Airdrop Limit: 75,000 tokens
// - Proof Types: LEVEL_UP, TOURNAMENT_WIN, DAILY_LOGIN, ACHIEVEMENT_UNLOCK

// After web app setup:
const gamingApiKey = "your_gaming_api_key";
const gamingVaultAddress = "your_gaming_vault_address";

// Handle level progression
async function handleLevelUp(playerId, newLevel, experienceGained) {
  const burnAmount = newLevel * 100; // Progressive burn
  const rewardAmount = experienceGained * 2; // Experience-based reward

  const pipeline = {
    type: "LEVEL_UP",
    payload: JSON.stringify({
      playerId,
      previousLevel: newLevel - 1,
      newLevel,
      experienceGained,
      totalExperience: await getPlayerExperience(playerId),
      timestamp: new Date().toISOString(),
    }),
    actions: [
      { action: "BURN", amount: burnAmount },
      {
        action: "AIRDROP",
        toAddress: await getPlayerWallet(playerId),
        amount: rewardAmount,
      },
    ],
  };

  return await executePipeline(pipeline);
}

// Handle tournament victories
async function handleTournamentWin(tournamentId, winnerId, prize) {
  const burnAmount = prize * 0.1; // Burn 10% of prize value
  const rewardAmount = prize; // Full prize to winner

  const pipeline = {
    type: "TOURNAMENT_WIN",
    payload: JSON.stringify({
      tournamentId,
      winnerId,
      prize,
      participants: await getTournamentParticipants(tournamentId),
      tournamentType: await getTournamentType(tournamentId),
      timestamp: new Date().toISOString(),
    }),
    actions: [
      { action: "BURN", amount: burnAmount },
      {
        action: "AIRDROP",
        toAddress: await getPlayerWallet(winnerId),
        amount: rewardAmount,
      },
      { action: "MEMO", message: `Tournament champion: ${tournamentId}` },
    ],
  };

  return await executePipeline(pipeline);
}

// Daily engagement rewards
async function handleDailyLogin(playerId, streakCount) {
  const baseReward = 100;
  const streakBonus = Math.min(streakCount * 10, 500); // Cap at 500
  const rewardAmount = baseReward + streakBonus;

  // Only airdrop for daily logins, no burn
  const pipeline = {
    type: "DAILY_LOGIN",
    payload: JSON.stringify({
      playerId,
      streakCount,
      previousLoginDate: await getLastLoginDate(playerId),
      timestamp: new Date().toISOString(),
    }),
    actions: [
      {
        action: "AIRDROP",
        toAddress: await getPlayerWallet(playerId),
        amount: rewardAmount,
      },
    ],
  };

  return await executePipeline(pipeline);
}

​
Community Funding Strategy

// Enable community to fund tournament prizes
async function createCommunityTournament(prizePool) {
  console.log(`Tournament funded by community: ${prizePool} tokens`);
  console.log(`Vault address: ${flywheelVaultAddress}`);
  console.log("Community can send tokens to increase prizes!");

  // Tournament operations will use community-funded tokens
}

​
Social Media Platform

Drive content creation and engagement through tokenized interactions.

​
Business Model

  • Trigger: Content creation, likes, shares, comments
  • Actions: Burn tokens for viral content + Reward creators and engaged users
  • Result: High-quality content incentives + Community-driven growth

​
Implementation

// Social platform flywheel (configured via web app)
// Setup at https://believe.app/projects:
// - Token: social_token_789
// - Daily Burn Limit: 200,000 tokens (high engagement platform)
// - Daily Airdrop Limit: 150,000 tokens
// - Proof Types: POST_VIRAL, CONTENT_CREATED, ENGAGEMENT_MILESTONE

// From web app registration:
const socialApiKey = "your_social_api_key";
const socialVaultAddress = "your_social_vault_address";

// Handle viral content
async function handleViralPost(postId, creatorId, interactions) {
  const burnAmount = interactions * 2; // Burn based on engagement
  const creatorReward = interactions * 5; // Higher reward for creator

  const pipeline = {
    type: "POST_VIRAL",
    payload: JSON.stringify({
      postId,
      creatorId,
      interactions: {
        likes: interactions.likes,
        shares: interactions.shares,
        comments: interactions.comments,
      },
      totalEngagement: interactions.total,
      viralThreshold: 1000,
      timestamp: new Date().toISOString(),
    }),
    actions: [
      { action: "BURN", amount: burnAmount },
      {
        action: "AIRDROP",
        toAddress: await getUserWallet(creatorId),
        amount: creatorReward,
      },
      { action: "MEMO", message: `Viral content reward: ${postId}` },
    ],
  };

  return await executePipeline(pipeline);
}

// Handle content creation
async function handleContentCreation(creatorId, contentType, quality) {
  const baseReward = 50;
  const qualityMultiplier = quality > 0.8 ? 2 : 1; // High quality bonus
  const rewardAmount = baseReward * qualityMultiplier;

  const pipeline = {
    type: "CONTENT_CREATED",
    payload: JSON.stringify({
      creatorId,
      contentType,
      qualityScore: quality,
      timestamp: new Date().toISOString(),
    }),
    actions: [
      {
        action: "AIRDROP",
        toAddress: await getUserWallet(creatorId),
        amount: rewardAmount,
      },
    ],
  };

  return await executePipeline(pipeline);
}

// Batch multiple engagement actions
async function handleEngagementBatch(engagements) {
  const pipelines = engagements.map((engagement) => ({
    type: "ENGAGEMENT_MILESTONE",
    payload: JSON.stringify({
      userId: engagement.userId,
      milestoneType: engagement.type,
      value: engagement.value,
      timestamp: new Date().toISOString(),
    }),
    actions: [
      {
        action: "AIRDROP",
        toAddress: engagement.userWallet,
        amount: engagement.reward,
      },
    ],
  }));

  // Execute multiple pipelines in a single batch
  return await executeBatch(pipelines);
}

​
Subscription Service

Convert subscription payments into token utility and customer rewards.

​
Business Model

  • Trigger: Subscription renewals, plan upgrades, referrals
  • Actions: Burn tokens for subscription value + Reward loyal subscribers
  • Result: Subscription retention + Token value appreciation

​
Implementation

// Subscription flywheel (configured via web app)
// Setup at https://believe.app/projects:
// - Token: subscription_token_101
// - Daily Burn Limit: 30,000 tokens (monthly cycles)
// - Daily Airdrop Limit: 20,000 tokens
// - Proof Types: SUBSCRIPTION_RENEWAL, PLAN_UPGRADE, REFERRAL_SUCCESS

// From web app registration:
const subscriptionApiKey = "your_subscription_api_key";
const subscriptionVaultAddress = "your_subscription_vault_address";

async function handleSubscriptionRenewal(
  subscriptionId,
  customerId,
  plan,
  monthsRenewed
) {
  const burnAmount = plan.monthlyPrice * monthsRenewed * 10;
  const loyaltyReward = monthsRenewed * 100; // Bonus for longer commitments

  const pipeline = {
    type: "SUBSCRIPTION_RENEWAL",
    payload: JSON.stringify({
      subscriptionId,
      customerId,
      plan: {
        name: plan.name,
        monthlyPrice: plan.monthlyPrice,
        features: plan.features,
      },
      monthsRenewed,
      totalValue: plan.monthlyPrice * monthsRenewed,
      timestamp: new Date().toISOString(),
    }),
    actions: [
      { action: "BURN", amount: burnAmount },
      {
        action: "AIRDROP",
        toAddress: await getCustomerWallet(customerId),
        amount: loyaltyReward,
      },
    ],
  };

  return await executePipeline(pipeline);
}

​
Community Funding Examples

All these use cases benefit from community participation:

​
Transparent Vault Funding

// Anyone can contribute to power the flywheel
const vaultAddress = "flywheel_vault_address_here";

// Community members can send tokens
await sendTokens(vaultAddress, amount);

// Project updates on funding status
async function getFundingStatus() {
  const balance = await getTokenBalance(vaultAddress);
  const solBalance = await getSolBalance(vaultAddress);

  return {
    tokenBalance: balance,
    solBalance: solBalance,
    estimatedOperationsRemaining: balance / averageDailyUsage,
    communityContributions: await getCommunityContributions(),
  };
}

​
Public Dashboard

// Show community the impact of their funding
async function getFlywheelStats() {
  return {
    totalTokensBurned: await getTotalBurned(),
    totalTokensAirdropped: await getTotalAirdropped(),
    uniqueParticipants: await getUniqueParticipants(),
    communityFunding: await getCommunityFunding(),
    recentTransactions: await getRecentTransactions(50),
  };
}

​
Implementation Tips

  1. Start Simple: Begin with basic burn/airdrop actions
  2. Fund Adequately: Ensure vault has sufficient tokens and SOL
  3. Monitor Daily Limits: Track usage against your configured limits
  4. Engage Community: Share vault address and funding status
  5. Iterate Based on Data: Adjust tokenomics based on actual usage
  6. Plan for Growth: Community funding can dramatically increase capacity
Each use case demonstrates how the Web App Registration → Fund → Batch Init → Execute flow creates sustainable, community-supported tokenomic systems that grow stronger over time! 🚀