Use Cases & Examples

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
}

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

Start Simple: Begin with basic burn/airdrop actions
Fund Adequately: Ensure vault has sufficient tokens and SOL
Monitor Daily Limits: Track usage against your configured limits
Engage Community: Share vault address and funding status
Iterate Based on Data: Adjust tokenomics based on actual usage
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! 🚀

API Documentation

Flywheel V1

Tokenomics (Deprecated)

E-Commerce Store

Business Model

Implementation

Expected Results

Gaming Platform

Business Model

Implementation

Community Funding Strategy

Business Model

Implementation

Subscription Service

Business Model

Implementation

Community Funding Examples

Transparent Vault Funding

Public Dashboard

Implementation Tips

​E-Commerce Store

​Business Model

​Implementation

​Expected Results

​Gaming Platform

​Business Model

​Implementation

​Community Funding Strategy

​Social Media Platform

​Business Model

​Implementation

​Subscription Service

​Business Model

​Implementation

​Community Funding Examples

​Transparent Vault Funding

​Public Dashboard

​Implementation Tips

E-Commerce Store

Business Model

Implementation

Expected Results

Gaming Platform

Business Model

Implementation

Community Funding Strategy

Social Media Platform

Business Model

Implementation

Subscription Service

Business Model

Implementation

Community Funding Examples

Transparent Vault Funding

Public Dashboard

Implementation Tips