DaddyX: Fan-Powered Event Finance on Solana

// oracle/src/pyth-reporter.ts
import { PythSolanaReceiver } from "@pythnetwork/pyth-solana-receiver";
import { Connection, PublicKey, Keypair } from "@solana/web3.js";

const SOL_USD_FEED_ID =
  "0xef0d8b6fda2ceba41da15d4095d1da392a0d2f8ed0c6c7bc0f4cfac8c280b56d";

export async function fetchSolUsdPrice(
  connection: Connection
): Promise<number> {
  const receiver = new PythSolanaReceiver({ connection });
  const feedAccount = await receiver.getFeedAccountAddress(
    0, // PYTHNET_SHARD
    SOL_USD_FEED_ID
  );
  const priceData = await receiver.fetchPriceData(feedAccount);
  // Use the EMA price for manipulation resistance
  return priceData.emaPrice.price * Math.pow(10, priceData.emaPrice.expo);
}

export async function buildRevenueReport(opts: {
  eventId: string;
  grossTicketRevenue: number; // in USD
  connection: Connection;
  oracleSigner: Keypair;
}): Promise<RevenueReport> {
  const solUsd = await fetchSolUsdPrice(opts.connection);
  const grossRevenueSol = opts.grossTicketRevenue / solUsd;

  return {
    eventId: opts.eventId,
    grossRevenueSol,
    solUsdAtSettlement: solUsd,
    reportedAt: Date.now(),
    oraclePubkey: opts.oracleSigner.publicKey.toBase58(),
  };
}

// oracle/src/revenue-reporter.ts
import { Program, AnchorProvider } from "@coral-xyz/anchor";
import { buildRevenueReport, fetchSolUsdPrice } from "./pyth-reporter";

export async function reportEventRevenue(
  program: Program,
  eventPda: PublicKey,
  oracleSigner: Keypair
) {
  // 1. Fetch gross revenue from ticketing APIs
  const grossUsd = await aggregateTicketRevenue(eventPda.toBase58());

  // 2. Get SOL/USD from Pyth (TWAP over 15-minute window)
  const connection = program.provider.connection;
  const solUsd = await fetchSolUsdPrice(connection);
  const grossSol = Math.floor((grossUsd / solUsd) * 1e9); // lamports

  // 3. Submit on-chain — oracle must be the event's nominated key
  const tx = await program.methods
    .reportRevenue(new BN(grossSol))
    .accounts({
      eventConfig: eventPda,
      oracle: oracleSigner.publicKey,
      systemProgram: SystemProgram.programId,
    })
    .signers([oracleSigner])
    .rpc();

  console.log("Revenue reported:", { grossUsd, grossSol, solUsd, tx });
  return tx;
}

// governance/src/dao-setup.ts
import {
  withCreateRealm,
  withCreateGovernance,
  withCreateProposal,
  VoteThresholdPercentage,
  VoteTipping,
  GovernanceConfig,
} from "@solana/spl-governance";
import { PublicKey, Transaction } from "@solana/web3.js";

const GOVERNANCE_PROGRAM_ID = new PublicKey(
  "GovER5Lthms3bLBqWub97yVrMmEogzX7xNjdXpPPCVZw"
);

const DADDYX_MINT = new PublicKey(
  "DADXYk1rGoVtokenMintXXXXXXXXXXXXXXXXXXXXXXXX" // mainnet address
);

export const GOVERNANCE_CONFIG: GovernanceConfig = {
  // Minimum tokens to create a proposal
  minCommunityTokensToCreateProposal: BigInt(100_000 * 1e6), // 100K $DADDYX

  // Quorum — 2% of circulating supply for standard proposals
  communityVoteThreshold: new VoteThresholdPercentage({ percent: 2 }),

  // Vote duration: 3 days standard, 7 days treasury
  baseVotingTime: 3 * 24 * 60 * 60, // seconds

  // Early approval if >67% voted yes with >10% quorum
  communityVoteTipping: VoteTipping.Early,

  // Timelock before execution
  votingCoolOffTime: 48 * 60 * 60, // 48 hours

  // Deposit required to submit proposal (returned on completion)
  minCouncilTokensToCreateProposal: BigInt(0),
};

export async function createDaddyXRealm(
  connection: Connection,
  payer: Keypair
): Promise<PublicKey> {
  const instructions: TransactionInstruction[] = [];

  const realmPda = await withCreateRealm(
    instructions,
    GOVERNANCE_PROGRAM_ID,
    3, // program version
    "DaddyX DAO",
    payer.publicKey,
    DADDYX_MINT,
    payer.publicKey,
    undefined, // no council token
    MintMaxVoteWeightSource.FULL_SUPPLY_FRACTION,
    new BN(1)
  );

  const tx = new Transaction().add(...instructions);
  await sendAndConfirmTransaction(connection, tx, [payer]);
  return realmPda;
}

# Install Solana Mobile dependencies
pnpm add @solana-mobile/mobile-wallet-adapter-protocol \
         @solana-mobile/wallet-standard-mobile \
         @solana/wallet-adapter-react \
         @solana/web3.js \
         @coral-xyz/anchor

// mobile/src/hooks/useMobileWallet.ts
import { useCallback, useMemo } from "react";
import {
  transact,
  Web3MobileWallet,
} from "@solana-mobile/mobile-wallet-adapter-protocol-web3js";
import {
  Connection,
  PublicKey,
  Transaction,
  clusterApiUrl,
} from "@solana/web3.js";

const DADDYX_APP_IDENTITY = {
  name: "DaddyX",
  uri: "https://daddyx.io",
  icon: "favicon.png",
};

const connection = new Connection(clusterApiUrl("devnet"), "confirmed");

export function useMobileWallet() {
  const connect = useCallback(async (): Promise<PublicKey> => {
    return await transact(async (wallet: Web3MobileWallet) => {
      const { accounts } = await wallet.authorize({
        cluster: "devnet",
        identity: DADDYX_APP_IDENTITY,
      });

      if (!accounts.length) throw new Error("No accounts authorized");
      return new PublicKey(accounts[0].publicKey);
    });
  }, []);

  const signAndSendTransaction = useCallback(
    async (transaction: Transaction): Promise<string> => {
      return await transact(async (wallet: Web3MobileWallet) => {
        const { accounts } = await wallet.authorize({
          cluster: "devnet",
          identity: DADDYX_APP_IDENTITY,
        });

        const { blockhash, lastValidBlockHeight } =
          await connection.getLatestBlockhash();

        transaction.recentBlockhash = blockhash;
        transaction.feePayer = new PublicKey(accounts[0].publicKey);

        const signedTxs = await wallet.signTransactions({
          transactions: [transaction],
        });

        const signature = await connection.sendRawTransaction(
          signedTxs[0].serialize()
        );

        await connection.confirmTransaction({
          signature,
          blockhash,
          lastValidBlockHeight,
        });

        return signature;
      });
    },
    []
  );

  return { connect, signAndSendTransaction };
}

// mobile/src/screens/EventScreen.tsx
import { useState } from "react";
import { View, Text, Pressable, Alert } from "react-native";
import { Program, AnchorProvider, BN } from "@coral-xyz/anchor";
import { useMobileWallet } from "../hooks/useMobileWallet";
import { DADDYX_PROGRAM_ID, IDL } from "../constants/program";

interface PurchaseTokenProps {
  eventPda: string;
  tokenId: number;
  currentPriceLamports: number;
  stepFactorBps: number;
}

export function PurchaseTokenButton({
  eventPda,
  tokenId,
  currentPriceLamports,
  stepFactorBps,
}: PurchaseTokenProps) {
  const { connect, signAndSendTransaction } = useMobileWallet();
  const [loading, setLoading] = useState(false);

  const purchasePrice =
    (currentPriceLamports * stepFactorBps) / 10_000;

  async function handlePurchase() {
    try {
      setLoading(true);
      const walletPubkey = await connect();

      // Build the purchase_token instruction
      const program = new Program(IDL, DADDYX_PROGRAM_ID);
      const ix = await program.methods
        .purchaseToken(tokenId, new BN(purchasePrice))
        .accounts({
          eventConfig: new PublicKey(eventPda),
          buyer: walletPubkey,
          systemProgram: SystemProgram.programId,
        })
        .instruction();

      const tx = new Transaction().add(ix);
      const signature = await signAndSendTransaction(tx);

      Alert.alert(
        "🎉 Token Backed!",
        `You paid ${purchasePrice / 1e9} SOL\nTx: ${signature.slice(0, 16)}…`
      );
    } catch (err) {
      Alert.alert("Error", String(err));
    } finally {
      setLoading(false);
    }
  }

  return (
    <Pressable
      onPress={handlePurchase}
      disabled={loading}
      style={{
        backgroundColor: "#ffb690",
        borderRadius: 9999,
        paddingVertical: 16,
        paddingHorizontal: 32,
        alignItems: "center",
      }}
    >
      <Text style={{ color: "#000", fontWeight: "700", fontSize: 14 }}>
        {loading ? "Signing…" : `Back This Event · ${(purchasePrice / 1e9).toFixed(3)} SOL`}
      </Text>
    </Pressable>
  );
}

// Generate a Solana Pay deep link for event venue QR codes
import { encodeURL, createTransfer } from "@solana/pay";
import BigNumber from "bignumber.js";

export function generateEventQR(opts: {
  recipientEscrowPda: PublicKey;
  purchasePriceSol: number;
  eventId: string;
  tokenId: number;
}): URL {
  return encodeURL({
    recipient: opts.recipientEscrowPda,
    amount: new BigNumber(opts.purchasePriceSol),
    splToken: undefined, // native SOL
    reference: [new PublicKey(Buffer.from(opts.eventId))],
    label: "DaddyX",
    message: `Back event ${opts.eventId} · Token #${opts.tokenId}`,
    memo: `DADDYX:${opts.eventId}:${opts.tokenId}`,
  });
}

// mobile/src/notifications.ts
import { SolanaMobileWalletAdapterProtocol } from "@solana-mobile/mobile-wallet-adapter-protocol";

export const NOTIFICATION_EVENTS = {
  TOKEN_RESOLD:   "daddyx.token.resold",    // you received payout
  REVENUE_SETTLED: "daddyx.revenue.settled", // claim your share
  PRICE_MILESTONE: "daddyx.price.milestone", // your token 2x'd
  EVENT_CANCELLED: "daddyx.event.cancelled", // claim refund
} as const;

export async function subscribeToEventNotifications(
  wallet: PublicKey,
  eventId: string,
  tokenId: number
): Promise<void> {
  await fetch("/api/notifications/subscribe", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      wallet: wallet.toBase58(),
      eventId,
      tokenId,
      events: Object.values(NOTIFICATION_EVENTS),
    }),
  });
}